feat(update): detect CivitAI paidAccess versions and add hide paid updates (#1060)

CivitAI's PaidAccess cutover deprecated the availability=EarlyAccess and
earlyAccessEndsAt signals; gated versions now report availability=Public
with a paidAccess DTO that LoRA Manager previously ignored, so "Hide
Early Access Updates" missed paid/early-access models and downloads
failed with 401.

Parse and persist paidAccess from model-level, bulk, and by-hash
responses; treat timed paid gates as early access and permanent paid
versions as a distinct is_paid state; add a hide_paid_updates setting
with a "Paid" badge in the versions tab; warn before downloading gated
versions. Includes SQLite migration, i18n for all locales, and
backend/frontend tests.

tests/routes/test_model_update_handler.py

@@ -593,3 +593,103 @@ async def test_fetch_missing_license_data_filters_model_ids(monkeypatch):
     assert len(payload["updated"]) == 1
     assert provider_calls == [[20]]
     assert len(saved) == 1
+
+
+def test_serialize_version_permanent_paid_is_not_early_access():
+    """Permanent paid versions (is_paid, no end date) must not be flagged as
+    early access, mirroring _is_early_access_active in the update service."""
+    version = ModelVersionRecord(
+        version_id=7, name="v7", base_model=None, released_at=None, size_bytes=None,
+        preview_url=None, is_in_library=False, should_ignore=False,
+        early_access_ends_at=None, is_early_access=True, usage_control="Download",
+        paid_access=json.dumps({"permanent": True, "endsAt": None}), is_paid=True,
+    )
+    serialized = ModelUpdateHandler._serialize_version(version, None)
+    assert serialized["isEarlyAccess"] is False
+    assert serialized["isPaid"] is True
+    assert serialized["paidAccess"] == {"permanent": True, "endsAt": None}
+
+
+def test_serialize_version_timed_paid_is_early_access():
+    """Timed paid gates (endsAt in the future) stay flagged as early access."""
+    version = ModelVersionRecord(
+        version_id=8, name="v8", base_model=None, released_at=None, size_bytes=None,
+        preview_url=None, is_in_library=False, should_ignore=False,
+        early_access_ends_at="2099-01-01T00:00:00.000Z", is_early_access=True,
+        usage_control="Download",
+        paid_access=json.dumps({"permanent": False, "endsAt": "2099-01-01T00:00:00.000Z"}),
+        is_paid=False,
+    )
+    serialized = ModelUpdateHandler._serialize_version(version, None)
+    assert serialized["isEarlyAccess"] is True
+    assert serialized["isPaid"] is False
+
+
+def test_serialize_version_malformed_paid_access_does_not_crash():
+    """A malformed paid_access row must degrade to None instead of failing
+    the whole versions-list response."""
+    version = ModelVersionRecord(
+        version_id=10, name="v10", base_model=None, released_at=None, size_bytes=None,
+        preview_url=None, is_in_library=False, should_ignore=False,
+        early_access_ends_at=None, is_early_access=True, usage_control=None,
+        paid_access="{not json", is_paid=False,
+    )
+    serialized = ModelUpdateHandler._serialize_version(version, None)
+    assert serialized["paidAccess"] is None
+    assert serialized["isEarlyAccess"] is True
+
+
+async def test_enrich_early_access_details_skips_permanent_paid(monkeypatch):
+    """Permanent paid versions must not trigger per-version CivitAI fetches in
+    _enrich_early_access_details: they are not early access and can never get
+    an end time, so enriching them is wasted API traffic."""
+    record = ModelUpdateRecord(
+        model_type="lora",
+        model_id=1,
+        versions=[
+            ModelVersionRecord(
+                version_id=100, name="paid", base_model=None, released_at=None,
+                size_bytes=None, preview_url=None, is_in_library=False,
+                should_ignore=False, early_access_ends_at=None,
+                is_early_access=True, usage_control="Download",
+                paid_access='{"permanent": true, "endsAt": null}', is_paid=True,
+            ),
+            ModelVersionRecord(
+                version_id=200, name="ea", base_model=None, released_at=None,
+                size_bytes=None, preview_url=None, is_in_library=False,
+                should_ignore=False, early_access_ends_at=None,
+                is_early_access=True, usage_control="Download",
+                paid_access=None, is_paid=False,
+            ),
+        ],
+        last_checked_at=1.0,
+        should_ignore_model=False,
+    )
+
+    fetched: list[int] = []
+
+    async def fake_version_info(version_id: str):
+        fetched.append(int(version_id))
+        return {"earlyAccessEndsAt": "2099-01-01T00:00:00.000Z"}, None
+
+    provider = SimpleNamespace(get_model_version_info=fake_version_info)
+
+    async def metadata_selector(name):
+        assert name == "civitai_api"
+        return provider
+
+    handler = ModelUpdateHandler(
+        service=DummyService(SimpleNamespace(raw_data=[], version_index={})),
+        update_service=SimpleNamespace(),
+        metadata_provider_selector=metadata_selector,
+        settings_service=SimpleNamespace(get=lambda *_: False),
+        logger=logging.getLogger(__name__),
+    )
+
+    enriched = await handler._enrich_early_access_details(record)
+
+    # Only the timed EA version (200) is fetched; the permanent paid one (100) is skipped.
+    assert fetched == [200]
+    enriched_map = {v.version_id: v for v in enriched.versions}
+    assert enriched_map[200].early_access_ends_at == "2099-01-01T00:00:00.000Z"
+    assert enriched_map[100].early_access_ends_at is None

tests/services/test_base_model_service.py

@@ -82,7 +82,9 @@ class StubUpdateService:
         self.bulk_calls = []
         self.bulk_error = bulk_error
 
-    async def has_updates_bulk(self, model_type, model_ids, hide_early_access: bool = False):
+    async def has_updates_bulk(
+        self, model_type, model_ids, hide_early_access: bool = False, hide_paid: bool = False
+    ):
         self.bulk_calls.append((model_type, list(model_ids)))
         if self.bulk_error:
             raise RuntimeError("bulk failure")
@@ -94,7 +96,9 @@ class StubUpdateService:
             results[model_id] = result
         return results
 
-    async def has_update(self, model_type, model_id, hide_early_access: bool = False):
+    async def has_update(
+        self, model_type, model_id, hide_early_access: bool = False, hide_paid: bool = False
+    ):
         self.calls.append((model_type, model_id))
         result = self.decisions.get(model_id, False)
         if isinstance(result, Exception):

tests/services/test_model_update_service.py

@@ -59,7 +59,17 @@ class NotFoundProvider:
         return {}
 
 
-def make_version(version_id, *, in_library, base_model=None, should_ignore=False):
+def make_version(
+    version_id,
+    *,
+    in_library,
+    base_model=None,
+    should_ignore=False,
+    early_access_ends_at=None,
+    is_early_access=False,
+    is_paid=False,
+    paid_access=None,
+):
     return ModelVersionRecord(
         version_id=version_id,
         name=None,
@@ -69,6 +79,10 @@ def make_version(version_id, *, in_library, base_model=None, should_ignore=False
         preview_url=None,
         is_in_library=in_library,
         should_ignore=should_ignore,
+        early_access_ends_at=early_access_ends_at,
+        is_early_access=is_early_access,
+        is_paid=is_paid,
+        paid_access=paid_access,
     )
 
 
@@ -622,3 +636,165 @@ async def test_refresh_folder_filter_considers_cross_folder_versions(tmp_path):
     # has_update must be True (version 20 > max_in_library=15)
     assert record.has_update() is True
 
+
+def test_extract_single_version_paid_access_timed(tmp_path):
+    """A timed paidAccess gate (permanent=False + future endsAt) is detected
+    as early access while availability stays 'Public'."""
+    db_path = tmp_path / "updates.sqlite"
+    service = ModelUpdateService(str(db_path))
+
+    entry = {
+        "id": 42,
+        "name": "v1 paid",
+        "availability": "Public",
+        "paidAccess": {
+            "permanent": False,
+            "endsAt": "2026-08-22T18:30:00.000Z",
+        },
+        "files": [],
+        "images": [],
+    }
+
+    version = service._extract_single_version(entry, index=0)
+
+    assert version is not None
+    assert version.is_early_access is True
+    assert version.early_access_ends_at == "2026-08-22T18:30:00.000Z"
+    assert version.is_paid is False
+    assert version.paid_access is not None
+
+
+def test_extract_single_version_paid_access_permanent(tmp_path):
+    """A permanent paidAccess gate (permanent=True, no endsAt) is detected and
+    flagged as paid but is NOT early access and carries no end date."""
+    db_path = tmp_path / "updates.sqlite"
+    service = ModelUpdateService(str(db_path))
+
+    entry = {
+        "id": 42,
+        "name": "v1 paid",
+        "availability": "Public",
+        "paidAccess": {"permanent": True, "endsAt": None},
+        "files": [],
+        "images": [],
+    }
+
+    version = service._extract_single_version(entry, index=0)
+
+    assert version is not None
+    assert version.is_early_access is False
+    assert version.is_paid is True
+    assert version.early_access_ends_at is None
+    assert version.paid_access is not None
+
+
+def test_normalize_paid_access_accepts_json_string():
+    """The by-hash enrichment path may hand paidAccess to _normalize_paid_access
+    as a JSON string; both the permanent and timed shapes must normalize."""
+    service = ModelUpdateService.__new__(ModelUpdateService)
+
+    permanent = ModelUpdateService._normalize_paid_access(
+        '{"permanent": true, "endsAt": null}'
+    )
+    assert permanent == {"permanent": True, "endsAt": None}
+
+    timed = ModelUpdateService._normalize_paid_access(
+        '{"permanent": false, "endsAt": "2026-08-22T18:30:00.000Z"}'
+    )
+    assert timed == {"permanent": False, "endsAt": "2026-08-22T18:30:00.000Z"}
+
+    empty = ModelUpdateService._normalize_paid_access(
+        '{"permanent": false, "endsAt": null}'
+    )
+    assert empty is None
+
+    malformed = ModelUpdateService._normalize_paid_access("{not json")
+    assert malformed is None
+
+
+def test_has_update_for_base_hide_paid():
+    """hide_paid also suppresses permanent paid versions in the same-base
+    update path (has_update_for_base)."""
+    record = make_record(
+        make_version(5, in_library=True, base_model="illustrious"),
+        make_version(
+            7,
+            in_library=False,
+            base_model="illustrious",
+            is_paid=True,
+            paid_access='{"permanent": true, "endsAt": null}',
+        ),
+    )
+
+    assert record.has_update_for_base(5, "illustrious") is True
+    assert record.has_update_for_base(5, "illustrious", hide_paid=True) is False
+
+
+def test_has_update_hide_paid():
+    """hide_paid suppresses update flags raised by a permanent paid version."""
+    record = make_record(
+        make_version(5, in_library=True),
+        make_version(
+            7,
+            in_library=False,
+            is_paid=True,
+            paid_access='{"permanent": true, "endsAt": null}',
+        ),
+    )
+
+    assert record.has_update() is True
+    assert record.has_update(hide_paid=True) is False
+
+
+def test_has_update_hide_early_access_paid_timed():
+    """hide_early_access suppresses a newer timed paidAccess version."""
+    record = make_record(
+        make_version(5, in_library=True),
+        make_version(
+            7,
+            in_library=False,
+            is_early_access=True,
+            early_access_ends_at="2099-01-01T00:00:00Z",
+        ),
+    )
+
+    assert record.has_update() is True
+    assert record.has_update(hide_early_access=True) is False
+
+
+
+def test_build_record_from_remote_preserves_paid_fields(tmp_path):
+    """_build_record_from_remote must carry paid_access/is_paid from the
+    parsed remote versions into the rebuilt record, or the refresh path
+    silently drops paid data before persistence."""
+    db_path = tmp_path / "updates.sqlite"
+    service = ModelUpdateService(str(db_path))
+
+    remote_version = ModelVersionRecord(
+        version_id=7,
+        name="v7",
+        base_model=None,
+        released_at=None,
+        size_bytes=None,
+        preview_url=None,
+        is_in_library=False,
+        should_ignore=False,
+        early_access_ends_at=None,
+        is_early_access=True,
+        usage_control="Download",
+        paid_access='{"permanent": true, "endsAt": null}',
+        is_paid=True,
+    )
+
+    record = service._build_record_from_remote(
+        model_type="lora",
+        model_id=123,
+        local_versions=[],
+        remote_versions=[remote_version],
+        existing=None,
+        timestamp=1.0,
+    )
+
+    rebuilt = record.versions[0]
+    assert rebuilt.paid_access == '{"permanent": true, "endsAt": null}'
+    assert rebuilt.is_paid is True