feat: Automatically update extensions on startup and on a schedule (#4314)
What changed, and why it matters
This commit adds an automatic extension update feature to LNbits. By default, it checks for and installs newer versions of installed extensions when the server starts, and can repeat that check every 24 hours. Because extensions are downloaded from external repositories and installed without a human reviewing the code, a compromised extension publisher or repository could push malicious code that LNbits would automatically run. The commit does include safeguards—only stable releases from the same source repo, version compatibility checks, and permission checks for WebAssembly extensions—but the feature is enabled by default and relies on the security of third-party extension sources.
Treat this as a supply-chain risk feature. Operators should disable automatic updates (`LNBITS_AUTOUPDATE_EXTENSIONS_ON_STARTUP=false` and `LNBITS_AUTOUPDATE_EXTENSIONS_INTERVAL_HOURS=0`) unless they fully trust every configured extension source. The project should add cryptographic signature verification of extension archives, an audit log of automatic updates, and an admin approval queue before automatic installation. Reviewers should also verify that `download_archive` uses TLS certificate validation and that the temporary backup directory is created with restrictive permissions.
Security signals we found
Automatic download and execution of third-party code is enabled by default
Update source is the extension's configured source_repo, not a vendor-curated store
No code signature or hash verification is visible in the diff beyond existing archive validation helpers
WebAssembly extension permission changes block silent updates, but Python extensions have no equivalent permission gate
Failed updates restore the previous archive from a temporary backup, reducing corruption risk
Shutdown or cancellation during download aborts installation and restores backup
Version selection excludes prereleases and incompatible versions, and requires same source repository
Evidence from the diff
The change introduces auto_update_extensions() and a scheduled task scheduled_extension_updates(). On startup, if lnbits_autoupdate_extensions_on_startup is true (default), it iterates installed extensions, queries their configured source repository for releases, picks the latest compatible non-prerelease from the same repo, downloads it to a temporary directory, swaps the zip archive, runs migrations, and installs/activates the update. For active Python extensions during scheduled updates, it deactivates the old version, clears sys.modules, and re-activates. WebAssembly extension updates are skipped if their requested permissions differ from currently granted permissions. The feature is controlled by two new settings, both editable in the admin UI and via environment variables, with the startup toggle defaulting to true and the interval defaulting to 24 hours.
Changed components
lnbits/core/services/extensions.pylnbits/core/tasks.pylnbits/app.pylnbits/core/models/extensions.pylnbits/core/helpers.pylnbits/settings.pylnbits/templates/components/admin/extensions.vueInspect captured patch +836 / −15
### .env.example
@@ -377,6 +377,12 @@ LNBITS_USER_DEFAULT_EXTENSIONS="lnurlp"
# Start LNbits core only. The extensions are not loaded.
# LNBITS_EXTENSIONS_DEACTIVATE_ALL=true
+# Enable automatic extension updates at startup.
+# LNBITS_AUTOUPDATE_EXTENSIONS_ON_STARTUP=true
+
+# Update installed extensions every N hours. Set to 0 to disable scheduled updates.
+# LNBITS_AUTOUPDATE_EXTENSIONS_INTERVAL_HOURS=24
+
# Public registration is disabled by default. Prefer the superuser creating
# users and inviting them individually. Explicitly opt in to public registration.
LNBITS_ALLOW_NEW_ACCOUNTS=false
### AGENTS.md
@@ -6,6 +6,7 @@ This file guides AI coding agents working on LNbits. Keep changes small, verifie
- Think before coding. State material assumptions. Ask when ambiguity affects correctness, security, payments, wallets, or data migrations.
- Prefer the simplest implementation that solves the request.
+- Use `assert` only in tests. In application code, use explicit checks and raise appropriate exceptions; Python can remove assertions when run with `-O` or `-OO`.
- Make surgical changes. Every changed line should trace back to the task.
- Do not refactor, reformat, rename, or clean adjacent code unless required.
- Remove only dead code or imports created by your own changes.
### lnbits/app.py
@@ -24,9 +24,13 @@
)
from lnbits.core.crud.audit import delete_expired_audit_entries
from lnbits.core.crud.extensions import create_installed_extension
-from lnbits.core.helpers import migrate_extension_database
+from lnbits.core.helpers import clear_extension_module_cache, migrate_extension_database
from lnbits.core.models.notifications import NotificationType
-from lnbits.core.services.extensions import deactivate_extension, get_valid_extensions
+from lnbits.core.services.extensions import (
+ auto_update_extensions,
+ deactivate_extension,
+ get_valid_extensions,
+)
from lnbits.core.services.funding_source import (
check_balance_delta_changed,
check_server_balance_against_node,
@@ -48,6 +52,7 @@
notify_server_status,
process_next_audit_entry,
refresh_extension_cache,
+ scheduled_extension_updates,
)
from lnbits.core.wasm_ext.routes.register import (
register_wasm_extension,
@@ -502,14 +507,7 @@ def register_ext_tasks(ext: Extension) -> None:
def register_ext_routes(app: FastAPI, ext: Extension) -> None:
"""Register FastAPI routes for extension."""
module_name = ext.module_name
- # Clear all cached sub-modules so a fresh import picks up new files from ext_dir.
- # A simple reload() would reuse cached sub-modules (e.g. views_api) and serve
- # stale code even after the extension files have been replaced on disk.
- stale = [
- k for k in sys.modules if k == module_name or k.startswith(f"{module_name}.")
- ]
- for k in stale:
- del sys.modules[k]
+ clear_extension_module_cache(module_name)
ext_module = importlib.import_module(module_name)
ext_route = getattr(ext_module, f"{ext.code}_ext")
@@ -550,6 +548,8 @@ def register_ext_routes(app: FastAPI, ext: Extension) -> None:
async def check_and_register_extensions(app: FastAPI) -> None:
+ if settings.lnbits_autoupdate_extensions_on_startup:
+ await auto_update_extensions()
await check_installed_extensions(app)
for ext in await get_valid_extensions(False):
try:
@@ -596,6 +596,7 @@ def register_async_tasks() -> None:
interval=60 * 60 * settings.lnbits_notification_server_status_hours,
)
task_manager.create_permanent_task(refresh_extension_cache, interval=60)
+ task_manager.create_permanent_task(scheduled_extension_updates, interval=60)
# permanent tasks run in a loop, will be restarted if they fail
task_manager.create_permanent_task(fundingsource_invoice_producer)
### lnbits/core/helpers.py
@@ -1,5 +1,6 @@
import importlib
import re
+import sys
from typing import Any
from urllib.parse import urlparse
from uuid import UUID
@@ -21,6 +22,18 @@
from lnbits.settings import settings
+def clear_extension_module_cache(module_name: str) -> None:
+ # Clear submodules too; reload() alone can leave old extension code cached.
+ stale = [
+ name
+ for name in sys.modules
+ if name == module_name or name.startswith(f"{module_name}.")
+ ]
+ for name in stale:
+ del sys.modules[name]
+ importlib.invalidate_caches()
+
+
async def migrate_extension_database(
ext: InstallableExtension, current_version: DbVersion | None = None
):
### lnbits/core/models/extensions.py
@@ -15,6 +15,7 @@
import httpx
from loguru import logger
+from packaging.version import InvalidVersion, Version
from pydantic import BaseModel, ConfigDict, Field, StrictStr
from lnbits.helpers import (
@@ -590,9 +591,9 @@ def is_wasm(self) -> bool:
return False
return config_json.get("extension_type") == "wasm"
- async def download_archive(self):
+ async def download_archive(self, archive_path: Path | None = None):
logger.info(f"Downloading extension {self.name} ({self.installed_version}).")
- ext_zip_file = self.zip_path
+ ext_zip_file = archive_path or self.zip_path
if ext_zip_file.is_file():
os.remove(ext_zip_file)
try:
@@ -784,6 +785,26 @@ def find_existing_payment(self, pay_link: str | None) -> ReleasePaymentInfo | No
None,
)
+ async def find_latest_compatible_release(self) -> ExtensionRelease | None:
+ installed = self.meta.installed_release if self.meta else None
+ if not installed or not installed.source_repo:
+ return None
+ latest = None
+ latest_version = Version(installed.version)
+ for release in await self.get_extension_releases(self.id):
+ if (
+ release.source_repo != installed.source_repo
+ or not release.is_version_compatible
+ ):
+ continue
+ try:
+ version = Version(release.version)
+ except InvalidVersion:
+ continue
+ if not version.is_prerelease and version > latest_version:
+ latest, latest_version = release, version
+ return latest
+
def _check_latest_version(self, release: ExtensionRelease | None):
if not release:
return
### lnbits/core/services/extensions.py
@@ -3,6 +3,8 @@
from collections.abc import Mapping
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from tempfile import TemporaryDirectory
from threading import RLock
from typing import Any
from uuid import uuid4
@@ -35,7 +37,7 @@
get_wasm_invocations as get_wasm_invocations_crud,
)
from lnbits.core.crud.scheduler import delete_namespace_schedules
-from lnbits.core.helpers import migrate_extension_database
+from lnbits.core.helpers import clear_extension_module_cache, migrate_extension_database
from lnbits.core.services.scheduler import scheduler
from lnbits.core.wasm_ext.api.permissions import validate_wasm_extension_permissions
from lnbits.core.wasm_ext.wasm.component import warm_wasm_extension
@@ -47,8 +49,10 @@
from ..models.extensions import (
Extension,
+ ExtensionConfig,
ExtensionMeta,
ExtensionPermission,
+ ExtensionRelease,
InstallableExtension,
WasmInvocation,
WasmInvocationStats,
@@ -192,6 +196,7 @@ async def install_extension(
skip_download: bool | None = False,
granted_permissions: list[ExtensionPermission] | None = None,
allow_admin_policy_overrides: bool = False,
+ stop_background_work: bool = True,
) -> Extension:
ext_info.meta = ext_info.meta or ExtensionMeta()
@@ -242,12 +247,38 @@ async def install_extension(
else:
await update_installed_extension(ext_info)
- if installed_ext:
+ if installed_ext and stop_background_work:
await stop_extension_background_work(ext_info.id)
return Extension.from_installable_ext(ext_info)
+async def auto_update_extensions(*, reload_active: bool = False) -> None:
+ if (
+ reload_active and settings.lnbits_autoupdate_extensions_interval_hours == 0
+ ) or settings.lnbits_extensions_deactivate_all:
+ return
+
+ for ext in await get_installed_extensions():
+ if not settings.lnbits_running:
+ return
+ try:
+ release = await ext.find_latest_compatible_release()
+ if release:
+ extension = await _auto_update_extension(
+ ext, release, reload_active=reload_active
+ )
+ if reload_active and ext.active:
+ try:
+ await activate_extension(extension)
+ except (Exception, asyncio.CancelledError):
+ await deactivate_extension(ext.id)
+ raise
+ logger.info(f"Updated extension {ext.id} to {release.version}.")
+ except Exception:
+ logger.warning(f"Could not automatically update extension '{ext.id}'.")
+
+
async def check_extensions_limit(installed_ext: InstallableExtension | None = None):
if settings.lnbits_max_extensions == 0 or installed_ext:
return
@@ -775,3 +806,96 @@ async def _ensure_wasm_extension_schedules(ext):
await scheduler.stop_namespace(f"extension:{ext.code}")
raise
return
+
+
+async def _auto_update_extension(
+ ext: InstallableExtension, release: ExtensionRelease, *, reload_active: bool
+) -> Extension:
+ updated = ext.model_copy(deep=True)
+ if updated.meta is None:
+ raise ValueError("Installed extension metadata is missing.")
+ release = release.model_copy(deep=True)
+ payment = ext.find_existing_payment(release.pay_link)
+ if payment:
+ release.payment_hash = payment.payment_hash
+ elif (
+ release.pay_link
+ and updated.meta.installed_release
+ and updated.meta.installed_release.pay_link == release.pay_link
+ ):
+ release.payment_hash = updated.meta.installed_release.payment_hash
+ updated.version = release.version
+ updated.meta.installed_release = release
+
+ # Stage downloads so cancellation cannot discard the installed release's archive.
+ zip_path = updated.zip_path
+ with TemporaryDirectory(dir=zip_path.parent) as backup_dir:
+ downloaded = Path(backup_dir, "update.zip")
+ await updated.download_archive(archive_path=downloaded)
+ backup = Path(backup_dir, "installed.zip")
+ if zip_path.is_file():
+ zip_path.replace(backup)
+ installing = False
+ try:
+ downloaded.replace(zip_path)
+ current = await get_installed_extension(ext.id)
+ if not current or current.meta != ext.meta:
+ raise ValueError("Installed extension changed during update.")
+ # Downloads can outlast an admin changing activation or permission grants.
+ updated.active = ext.active = current.active
+ updated.permissions = current.permissions
+ permissions = _validate_extension_update(updated)
+ if (
+ not settings.lnbits_running
+ or (
+ reload_active
+ and settings.lnbits_autoupdate_extensions_interval_hours == 0
+ )
+ or settings.lnbits_extensions_deactivate_all
+ ):
+ raise ValueError("Extension auto-update stopped before installation.")
+ installing = True
+ return await _install_extension_update(updated, permissions, reload_active)
+ except (Exception, asyncio.CancelledError):
+ zip_path.unlink(missing_ok=True)
+ if backup.is_file():
+ backup.replace(zip_path)
+ if installing:
+ await deactivate_extension(ext.id)
+ raise
+
+
+def _validate_extension_update(ext: InstallableExtension) -> list[ExtensionPermission]:
+ config = ext.load_archive_config()
+ if not ExtensionConfig.model_validate(config).is_version_compatible():
+ raise ValueError("Incompatible extension version")
+ ext.validate_archive(config)
+ if config.get("extension_type") != "wasm":
+ return []
+
+ requested = ExtensionPermission.list_from_config(config)
+ granted = {permission.id: permission.policies for permission in ext.permissions}
+ if any(
+ permission.id not in granted or permission.policies != granted[permission.id]
+ for permission in requested
+ ):
+ logger.info(f"Skipping extension '{ext.id}': permission approval required.")
+ raise ValueError("Extension update requires permission approval.")
+ return validate_wasm_extension_permissions(ext, requested, config)
+
+
+async def _install_extension_update(
+ updated: InstallableExtension,
+ permissions: list[ExtensionPermission],
+ reload_active: bool,
+) -> Extension:
+ if reload_active and updated.active:
+ await deactivate_extension(updated.id)
+ # Migrations must import the updated code before activation reloads routes.
+ clear_extension_module_cache(updated.module_name)
+ return await install_extension(
+ updated,
+ skip_download=True,
+ granted_permissions=permissions,
+ stop_background_work=not reload_active,
+ )
### lnbits/core/tasks.py
@@ -1,4 +1,5 @@
import asyncio
+from time import monotonic
from loguru import logger
@@ -9,6 +10,7 @@
from lnbits.core.models.audit import AuditEntry
from lnbits.core.models.extensions import InstallableExtension
from lnbits.core.models.notifications import NotificationType
+from lnbits.core.services.extensions import auto_update_extensions
from lnbits.core.services.funding_source import get_balance_delta
from lnbits.core.services.notifications import (
enqueue_admin_notification,
@@ -19,6 +21,7 @@
from lnbits.utils.exchange_rates import btc_price_from_aggregator, btc_rates
audit_queue: asyncio.Queue[AuditEntry] = asyncio.Queue()
+_last_extension_update_check: float | None = None
async def process_next_audit_entry() -> None:
@@ -35,6 +38,22 @@ async def refresh_extension_cache() -> None:
await InstallableExtension.get_installable_extensions()
+async def scheduled_extension_updates() -> None:
+ global _last_extension_update_check
+
+ now = monotonic()
+ if _last_extension_update_check is None:
+ # Startup already checked for updates.
+ _last_extension_update_check = now
+
+ interval = settings.lnbits_autoupdate_extensions_interval_hours
+ if interval == 0 or now - _last_extension_update_check < interval * 60 * 60:
+ return
+
+ _last_extension_update_check = monotonic()
+ await auto_update_extensions(reload_active=True)
+
+
async def notify_server_status() -> None:
accounts = await get_accounts(filters=Filters(limit=0))
wallets_count = await get_wallets_count()
### lnbits/settings.py
@@ -87,6 +87,8 @@ class ExtensionsSettings(LNbitsSettings):
lnbits_admin_extensions: list[str] = Field(default=[])
lnbits_user_default_extensions: list[str] = Field(default=[])
lnbits_extensions_deactivate_all: bool = Field(default=False)
+ lnbits_autoupdate_extensions_on_startup: bool = Field(default=True)
+ lnbits_autoupdate_extensions_interval_hours: int = Field(default=24, ge=0)
lnbits_extensions_builder_activate_non_admins: bool = Field(default=False)
lnbits_wasm_invocation_retention_days: int = Field(default=7, ge=0)
lnbits_extensions_reviews_url: str = Field(
### lnbits/templates/components/admin/extensions.vue
@@ -117,6 +117,36 @@
<p>
<span v-text="$t('miscellanous')"></span>
</p>
+ <q-item tag="label" v-ripple>
+ <q-item-section>
+ <q-item-label>Update extensions on startup</q-item-label>
+ <q-item-label caption>
+ Update installed extensions when LNbits starts.
+ </q-item-label>
+ </q-item-section>
+ <q-item-section avatar>
+ <q-toggle
+ size="md"
+ v-model="formData.lnbits_autoupdate_extensions_on_startup"
+ checked-icon="check"
+ color="green"
+ unchecked-icon="clear"
+ />
+ </q-item-section>
+ </q-item>
+ <q-input
+ dense
+ filled
+ class="q-mb-md"
+ v-model.number="
+ formData.lnbits_autoupdate_extensions_interval_hours
+ "
+ type="number"
+ min="0"
+ step="1"
+ label="Extension update interval (hours)"
+ hint="0 disables scheduled updates. Startup updates use the toggle above."
+ ></q-input>
<q-item tag="label" v-ripple>
<q-item-section>
<q-item-label>
### tests/unit/test_app_extensions.py
@@ -4,10 +4,189 @@
import pytest
from pytest_mock.plugin import MockerFixture
-from lnbits.app import build_all_installed_extensions_list
+from lnbits.app import (
+ build_all_installed_extensions_list,
+ check_and_register_extensions,
+ register_async_tasks,
+)
+from lnbits.core.tasks import scheduled_extension_updates
from lnbits.settings import Settings
+@pytest.fixture
+def extension_update_schedule(mocker, monkeypatch):
+ monkeypatch.setattr("lnbits.core.tasks._last_extension_update_check", None)
+ clock = mocker.patch("lnbits.core.tasks.monotonic", return_value=0)
+ update = mocker.patch("lnbits.core.tasks.auto_update_extensions")
+ return clock, update
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("enabled", [True, False])
+async def test_startup_updates_extensions_before_restoring_and_registering(
+ mocker, settings, enabled
+):
+ settings.lnbits_autoupdate_extensions_on_startup = enabled
+ calls = mocker.Mock()
+ for name in (
+ "auto_update_extensions",
+ "check_installed_extensions",
+ "get_valid_extensions",
+ ):
+ calls.attach_mock(mocker.patch(f"lnbits.app.{name}", return_value=[]), name)
+ app = mocker.Mock()
+
+ await check_and_register_extensions(app)
+
+ expected_calls = [mocker.call.auto_update_extensions()] if enabled else []
+ assert calls.mock_calls == [
+ *expected_calls,
+ mocker.call.check_installed_extensions(app),
+ mocker.call.get_valid_extensions(False),
+ ]
+
+
+def test_scheduled_extension_updates_are_registered(mocker):
+ manager = mocker.patch("lnbits.app.task_manager")
+ mocker.patch("lnbits.app.initialize_server_websocket_logger")
+
+ register_async_tasks()
+
+ manager.create_permanent_task.assert_any_call(
+ scheduled_extension_updates, interval=60
+ )
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("interval", [1, 12, 24])
+async def test_scheduled_extension_updates_use_configured_interval(
+ settings, extension_update_schedule, interval
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = interval
+ await scheduled_extension_updates()
+
+ clock.return_value = interval * 3600 - 1
+ await scheduled_extension_updates()
+ update.assert_not_awaited()
+
+ clock.return_value = interval * 3600
+ await scheduled_extension_updates()
+ update.assert_awaited_once_with(reload_active=True)
+
+ clock.return_value = interval * 7200 - 1
+ await scheduled_extension_updates()
+ update.assert_awaited_once()
+
+ clock.return_value = interval * 7200
+ await scheduled_extension_updates()
+ assert update.await_count == 2
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("initial_interval", [0, 1])
+async def test_scheduled_extension_updates_wait_while_disabled_and_can_be_enabled(
+ settings, extension_update_schedule, initial_interval
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = initial_interval
+ await scheduled_extension_updates()
+
+ settings.lnbits_autoupdate_extensions_interval_hours = 0
+ clock.return_value = 3600
+ await scheduled_extension_updates()
+ update.assert_not_awaited()
+
+ settings.lnbits_autoupdate_extensions_interval_hours = 1
+ clock.return_value = 3660
+ await scheduled_extension_updates()
+ update.assert_awaited_once_with(reload_active=True)
+
+
+@pytest.mark.anyio
+async def test_shorter_extension_update_interval_applies_on_next_tick(
+ settings, extension_update_schedule
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = 24
+ await scheduled_extension_updates()
+
+ clock.return_value = 3600
+ await scheduled_extension_updates()
+ update.assert_not_awaited()
+
+ settings.lnbits_autoupdate_extensions_interval_hours = 1
+ clock.return_value = 3660
+ await scheduled_extension_updates()
+ update.assert_awaited_once_with(reload_active=True)
+
+
+@pytest.mark.anyio
+async def test_longer_extension_update_interval_delays_next_check(
+ settings, extension_update_schedule
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = 1
+ await scheduled_extension_updates()
+
+ settings.lnbits_autoupdate_extensions_interval_hours = 24
+ clock.return_value = 3600
+ await scheduled_extension_updates()
+ update.assert_not_awaited()
+
+ clock.return_value = 86400
+ await scheduled_extension_updates()
+ update.assert_awaited_once_with(reload_active=True)
+
+
+@pytest.mark.anyio
+async def test_extension_update_interval_starts_when_check_begins(
+ settings, extension_update_schedule
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = 1
+ await scheduled_extension_updates()
+
+ async def finish_update(**kwargs):
+ clock.return_value += 30
+
+ update.side_effect = finish_update
+ clock.return_value = 3600
+ await scheduled_extension_updates()
+ update.assert_awaited_once()
+
+ clock.return_value = 7199
+ await scheduled_extension_updates()
+ update.assert_awaited_once()
+
+ clock.return_value = 7200
+ await scheduled_extension_updates()
+ assert update.await_count == 2
+
+
+@pytest.mark.anyio
+async def test_failed_extension_update_waits_for_configured_interval(
+ settings, extension_update_schedule
+):
+ clock, update = extension_update_schedule
+ settings.lnbits_autoupdate_extensions_interval_hours = 2
+ await scheduled_extension_updates()
+ update.side_effect = ValueError("Update check failed")
+
+ clock.return_value = 7200
+ with pytest.raises(ValueError, match="Update check failed"):
+ await scheduled_extension_updates()
+
+ clock.return_value = 10800
+ await scheduled_extension_updates()
+ update.assert_awaited_once()
+
+ clock.return_value = 14400
+ with pytest.raises(ValueError, match="Update check failed"):
+ await scheduled_extension_updates()
+ assert update.await_count == 2
+
+
@pytest.mark.anyio
async def test_wasm_extension_discovery_uses_configured_directory(
tmp_path: Path,
### tests/unit/test_extension_autoupdate.py
@@ -0,0 +1,425 @@
+import asyncio
+import importlib
+import json
+import sys
+import zipfile
+from types import SimpleNamespace
+
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+
+from lnbits.app import register_new_ext_routes
+from lnbits.core.models.extensions import (
+ ExtensionPermission,
+ InstallableExtension,
+ ReleasePaymentInfo,
+)
+from lnbits.core.services import extensions as services
+from lnbits.settings import EditableSettings, ExtensionsSettings, Settings
+from tests.helpers import make_extension_release, make_installable_extension
+
+
+@pytest.fixture
+def update_context(tmp_path, settings, monkeypatch, mocker):
+ monkeypatch.setattr(settings, "lnbits_data_folder", str(tmp_path / "data"))
+ monkeypatch.setattr(settings, "lnbits_extensions_path", str(tmp_path / "code"))
+ monkeypatch.setattr(settings, "lnbits_wasm_extensions_path", str(tmp_path / "wasm"))
+ monkeypatch.setattr(settings, "lnbits_autoupdate_extensions_interval_hours", 24)
+ monkeypatch.setattr(settings, "lnbits_extensions_deactivate_all", False)
+ monkeypatch.setattr(settings, "lnbits_running", True)
+ monkeypatch.setattr(settings, "lnbits_deactivated_extensions", set())
+ monkeypatch.syspath_prepend(str(tmp_path / "code" / "extensions"))
+ ext = make_installable_extension("autoupdate_demo")
+ assert ext.meta and ext.meta.installed_release
+ ext.meta.installed_release.payment_hash = "existing-payment"
+ release = make_extension_release(ext.id, "2.0.0")
+ release.hash = None
+ config = {
+ "id": ext.id,
+ "name": ext.name,
+ "version": release.version,
+ "short_description": "Updated extension",
+ }
+ ext.zip_path.write_bytes(b"cached installed release")
+
+ def download(_url, path):
+ with zipfile.ZipFile(path, "w") as archive:
+ archive.writestr(f"{ext.id}/config.json", json.dumps(config))
+ if config.get("extension_type") == "wasm":
+ archive.writestr(f"{ext.id}/extension.wasm", b"module")
+ else:
+ archive.writestr(
+ f"{ext.id}/__init__.py",
+ "from fastapi import APIRouter\n"
+ "VERSION = '2.0.0'\n"
+ f"{ext.id}_ext = APIRouter(prefix='/{ext.id}')\n"
+ f"@{ext.id}_ext.get('/version')\n"
+ "async def version():\n"
+ " return VERSION\n",
+ )
+
+ download_mock = mocker.patch(
+ "lnbits.core.models.extensions.download_url", side_effect=download
+ )
+ releases_mock = mocker.patch.object(
+ InstallableExtension, "get_extension_releases", return_value=[release]
+ )
+ mocker.patch.object(services, "get_installed_extensions", return_value=[ext])
+ mocker.patch.object(services, "get_installed_extension", return_value=ext)
+ mocker.patch.object(services, "get_db_version", return_value=None)
+ migrate = mocker.patch.object(services, "migrate_extension_database")
+ save = mocker.patch.object(services, "update_installed_extension")
+ deactivate = mocker.patch.object(services, "update_installed_extension_state")
+ stop = mocker.patch.object(services, "stop_extension_background_work")
+ mocker.patch.object(services, "load_wasm_extension")
+ mocker.patch.object(services, "warm_wasm_extension")
+ yield SimpleNamespace(
+ ext=ext,
+ release=release,
+ config=config,
+ releases=releases_mock,
+ download=download_mock,
+ migrate=migrate,
+ save=save,
+ deactivate=deactivate,
+ stop=stop,
+ )
+ sys.modules.pop(ext.module_name, None)
+
+
+@pytest.mark.parametrize("interval", [0, 1, 24])
+def test_autoupdate_interval_defaults_daily_and_loads_from_env(monkeypatch, interval):
+ assert ExtensionsSettings().lnbits_autoupdate_extensions_interval_hours == 24
+ monkeypatch.setenv("LNBITS_AUTOUPDATE_EXTENSIONS_INTERVAL_HOURS", str(interval))
+ loaded = Settings(_env_file=None) # pyright: ignore[reportCallIssue]
+ assert loaded.lnbits_autoupdate_extensions_interval_hours == interval
+ assert (
+ "lnbits_autoupdate_extensions_interval_hours" in EditableSettings.model_fields
+ )
+
+
+@pytest.mark.parametrize("interval", [-1, 1.5])
+def test_autoupdate_interval_rejects_negative_and_fractional_values(interval):
+ with pytest.raises(ValueError):
+ EditableSettings(lnbits_autoupdate_extensions_interval_hours=interval)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+ "disable_all,reload_active", [(True, False), (True, True), (False, True)]
+)
+async def test_autoupdate_disabled_does_not_fetch(
+ update_context, settings, disable_all, reload_active
+):
+ settings.lnbits_autoupdate_extensions_interval_hours = 24 if disable_all else 0
+ settings.lnbits_extensions_deactivate_all = disable_all
+ await services.auto_update_extensions(reload_active=reload_active)
+ update_context.releases.assert_not_awaited()
+ update_context.download.assert_not_called()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("active", [True, False])
+@pytest.mark.parametrize("interval", [0, 24])
+async def test_autoupdate_latest_compatible_preserves_state_and_paid_access(
+ update_context, settings, monkeypatch, active, interval
+):
+ ctx = update_context
+ settings.lnbits_autoupdate_extensions_interval_hours = interval
+ ctx.ext.active = active
+ if active:
+ ctx.ext.meta.payments = [
+ ReleasePaymentInfo(
+ pay_link=ctx.release.pay_link, payment_hash="existing-payment"
+ )
+ ]
+ if not active:
+ settings.lnbits_deactivated_extensions.add(ctx.ext.id)
+ ctx.releases.return_value = [
+ ctx.release.model_copy(update={"version": "1.5.0"}),
+ ctx.release,
+ ctx.release.model_copy(
+ update={"version": "3.0.0", "is_version_compatible": False}
+ ),
+ ctx.release.model_copy(update={"version": "4.0.0rc1"}),
+ ctx.release.model_copy(update={"version": "invalid"}),
+ ctx.release.model_copy(
+ update={"version": "5.0.0", "source_repo": "other/repo"}
+ ),
+ ]
+ monkeypatch.setitem(
+ sys.modules, ctx.ext.module_name, SimpleNamespace(VERSION="1.0.0")
+ )
+
+ async def migrate(ext, _version):
+ assert importlib.import_module(ext.module_name).VERSION == "2.0.0"
+
+ ctx.migrate.side_effect = migrate
+ await services.auto_update_extensions()
+
+ saved = ctx.save.await_args.args[0]
+ assert saved.version == "2.0.0"
+ assert saved.active is active
+ assert (ctx.ext.id in settings.lnbits_deactivated_extensions) is (not active)
+ assert "payment_hash=existing-payment" in ctx.download.call_args.args[0]
+ assert saved.meta.installed_release.payment_hash == "existing-payment"
+ assert saved.meta.payments == ctx.ext.meta.payments
+ assert ctx.ext.installed_version == "1.0.0"
+ ctx.deactivate.assert_not_awaited()
+ assert zipfile.is_zipfile(ctx.ext.zip_path)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("version", ["0.5.0", "1.0.0", "2.0.0rc1", "2.0.0.dev1"])
+async def test_autoupdate_does_not_downgrade_reinstall_or_install_prereleases(
+ update_context, version
+):
+ update_context.release.version = version
+ await services.auto_update_extensions()
+ update_context.download.assert_not_called()
+ update_context.save.assert_not_awaited()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("failure", ["download", "compatibility", "hash", "migration"])
+async def test_autoupdate_failure_preserves_archive_and_continues(
+ update_context, settings, mocker, failure
+):
+ ctx = update_context
+ if failure == "download":
+ ctx.download.side_effect = OSError("Offline")
+ elif failure == "compatibility":
+ ctx.config["min_lnbits_version"] = "9999.0.0"
+ elif failure == "hash":
+ ctx.release.hash = "incorrect-hash"
+ else:
+ ctx.migrate.side_effect = ValueError("Migration failed")
+ second = make_installable_extension("another_extension")
+ mocker.patch.object(
+ services, "get_installed_extensions", return_value=[ctx.ext, second]
+ )
+ ctx.releases.side_effect = [[ctx.release], []]
+
+ await services.auto_update_extensions()
+
+ assert ctx.ext.zip_path.read_bytes() == b"cached installed release"
+ ctx.save.assert_not_awaited()
+ assert ctx.releases.await_count == 2
+ if failure == "migration":
+ ctx.deactivate.assert_awaited_once_with(ext_id=ctx.ext.id, active=False)
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+ else:
+ ctx.deactivate.assert_not_awaited()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("permission_change", ["unchanged", "new", "broader"])
+async def test_autoupdate_wasm_requires_approval_for_permission_changes(
+ update_context, permission_change
+):
+ ctx = update_context
+ permission = ExtensionPermission(
+ id="http.request", policies=[{"host": "https://api.example.com"}]
+ )
+ ctx.ext.permissions = [permission]
+ ctx.config.update(
+ extension_type="wasm",
+ wasm={"module": "extension.wasm"},
+ permissions=[permission.model_dump()],
+ )
+ if permission_change == "new":
+ ctx.config["permissions"].append({"id": "wallet.read"})
+ elif permission_change == "broader":
+ ctx.config["permissions"][0]["policies"].append({"host": "https://new.example"})
+
+ await services.auto_update_extensions()
+
+ if permission_change == "unchanged":
+ ctx.save.assert_awaited_once()
+ assert ctx.save.await_args.args[0].permissions == [permission]
+ assert (ctx.ext.wasm_ext_dir / "extension.wasm").is_file()
+ else:
+ ctx.save.assert_not_awaited()
+ ctx.migrate.assert_not_awaited()
+ assert not ctx.ext.wasm_ext_dir.exists()
+ assert ctx.ext.zip_path.read_bytes() == b"cached installed release"
+ ctx.deactivate.assert_not_awaited()
+
+
+@pytest.mark.anyio
+async def test_autoupdate_shutdown_during_download_does_not_install(
+ update_context, settings
+):
+ ctx = update_context
+ download = ctx.download.side_effect
+
+ def stop_after_download(url, path):
+ download(url, path)
+ settings.lnbits_running = False
+
+ ctx.download.side_effect = stop_after_download
+ await services.auto_update_extensions()
+ ctx.save.assert_not_awaited()
+ ctx.deactivate.assert_not_awaited()
+ assert ctx.ext.zip_path.read_bytes() == b"cached installed release"
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("active", [True, False])
+async def test_periodic_autoupdate_reloads_only_active_python_extensions(
+ update_context, settings, mocker, monkeypatch, active
+):
+ ctx = update_context
+ settings.lnbits_autoupdate_extensions_on_startup = False
+ ctx.ext.active = active
+ if not active:
+ settings.lnbits_deactivated_extensions.add(ctx.ext.id)
+ app = FastAPI()
+
+ @app.get(f"/{ctx.ext.id}/version")
+ async def old_version():
+ return "1.0.0"
+
+ monkeypatch.setitem(
+ sys.modules, ctx.ext.module_name, SimpleNamespace(VERSION="1.0.0")
+ )
+
+ async def stop(ext_id):
+ assert ext_id == ctx.ext.id
+ assert sys.modules[ctx.ext.module_name].VERSION == "1.0.0"
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+
+ ctx.stop.side_effect = stop
+ mocker.patch.object(
+ services.core_app_extra,
+ "register_new_ext_routes",
+ side_effect=register_new_ext_routes(app),
+ )
+ start = mocker.patch.object(services, "start_extension_background_work")
+
+ await services.auto_update_extensions(reload_active=True)
+
+ assert ctx.save.await_args.args[0].active is active
+ if active:
+ ctx.stop.assert_awaited_once_with(ctx.ext.id)
+ start.assert_awaited_once_with(ctx.ext.id)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="http://test"
+ ) as client:
+ response = await client.get(f"/{ctx.ext.id}/version")
+ assert response.json() == "2.0.0"
+ assert ctx.ext.id not in settings.lnbits_deactivated_extensions
+ else:
+ ctx.stop.assert_not_awaited()
+ start.assert_not_awaited()
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+
+
+@pytest.mark.anyio
+async def test_periodic_autoupdate_reloads_wasm_routes_and_schedules(
+ update_context, mocker
+):
+ ctx = update_context
+ ctx.config.update(extension_type="wasm", wasm={"module": "extension.wasm"})
+ register = mocker.patch.object(
+ services.core_app_extra, "register_new_wasm_ext_routes"
+ )
+ schedules = mocker.patch.object(services, "ensure_wasm_extension_schedules")
+
+ await services.auto_update_extensions(reload_active=True)
+
+ register.assert_called_once_with(ctx.ext.id)
+ schedules.assert_awaited_once_with(ctx.ext.id)
+ ctx.stop.assert_awaited_once_with(ctx.ext.id)
+
+
+@pytest.mark.anyio
+async def test_periodic_autoupdate_activation_failure_leaves_extension_disabled(
+ update_context, settings, mocker
+):
+ ctx = update_context
+ mocker.patch.object(
+ services, "activate_extension", side_effect=ValueError("Cannot load routes")
+ )
+
+ await services.auto_update_extensions(reload_active=True)
+
+ ctx.save.assert_awaited_once()
+ assert ctx.deactivate.await_args.kwargs == {"ext_id": ctx.ext.id, "active": False}
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+ # Installation committed the new version before activation failed.
+ assert ctx.ext.load_archive_config()["version"] == ctx.release.version
+
+
+@pytest.mark.anyio
+async def test_periodic_autoupdate_preserves_deactivation_during_download(
+ update_context, settings, mocker
+):
+ ctx = update_context
+ download = ctx.download.side_effect
+
+ def deactivate_during_download(url, path):
+ download(url, path)
+ ctx.ext.active = False
+ settings.lnbits_deactivated_extensions.add(ctx.ext.id)
+
+ ctx.download.side_effect = deactivate_during_download
+ activate = mocker.patch.object(services, "activate_extension")
+
+ await services.auto_update_extensions(reload_active=True)
+
+ assert ctx.save.await_args.args[0].active is False
+ activate.assert_not_awaited()
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+
+
+@pytest.mark.anyio
+async def test_periodic_autoupdate_preserves_permissions_revoked_during_download(
+ update_context,
+):
+ ctx = update_context
+ permission = ExtensionPermission(id="wallet.read")
+ ctx.ext.permissions = [permission]
+ ctx.config.update(
+ extension_type="wasm",
+ wasm={"module": "extension.wasm"},
+ permissions=[permission.model_dump()],
+ )
+ download = ctx.download.side_effect
+
+ def revoke_during_download(url, path):
+ download(url, path)
+ ctx.ext.permissions = []
+
+ ctx.download.side_effect = revoke_during_download
+
+ await services.auto_update_extensions(reload_active=True)
+
+ ctx.save.assert_not_awaited()
+ ctx.stop.assert_not_awaited()
+ assert ctx.ext.zip_path.read_bytes() == b"cached installed release"
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("phase", ["download", "migration"])
+async def test_autoupdate_cancellation_preserves_cached_archive(
+ update_context, settings, mocker, phase
+):
+ ctx = update_context
+ if phase == "download":
+ mocker.patch.object(
+ InstallableExtension, "download_archive", side_effect=asyncio.CancelledError
+ )
+ else:
+ ctx.migrate.side_effect = asyncio.CancelledError
+
+ with pytest.raises(asyncio.CancelledError):
+ await services.auto_update_extensions(reload_active=True)
+
+ assert ctx.ext.zip_path.read_bytes() == b"cached installed release"
+ ctx.save.assert_not_awaited()
+ if phase == "migration":
+ assert ctx.ext.id in settings.lnbits_deactivated_extensions
+ else:
+ ctx.deactivate.assert_not_awaited()Why this scored 63/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.