Add the via-manager source to bulk firmware updates

The bulk update dialog only offered the device's own internet path, so an offline fleet could not be updated in one go. The bulk endpoint now accepts the same source field as the single-device route and runs the local path device by device, reusing the cached bundle per app. The dialog gains the source selector, resets its update choices on close, and uses timeout and progress estimates that fit the slower sequential path.

The CLI's local update now honours --channel too: the stable-only guard predated the channel-aware interactor and its loop never forwarded the choice.

Author: jfmlima

README.md

@@ -230,7 +230,7 @@ Earlier images wrote to `/app/data` instead. If you carried that over with a mou
 
 **Scheduled backups** run on the API server itself. When `SHELLY_BACKUP_SCHEDULER_ENABLED` is `true` (the default), an in-process poller captures backups for any due schedules every `SHELLY_BACKUP_POLL_INTERVAL_SECONDS` (default 60). Because the timer lives in-process, run the API as a single worker (the default); see the [API README](packages/api/README.md) for the full setting reference.
 
-**Local firmware updates** let a device that cannot reach the internet still be updated. Ask for one with `"source": "local"` on the update endpoint, or `--source local` from the CLI: the manager downloads the official firmware from Shelly once, keeps it, and tells the device to fetch it from the manager instead. The same copy serves every device running that model, so only the manager needs internet access.
+**Local firmware updates** let a device that cannot reach the internet still be updated. Ask for one with `"source": "local"` on the update endpoint (single-device or bulk), or `--source local` from the CLI: the manager downloads the official firmware from Shelly once, keeps it, and tells the device to fetch it from the manager instead. The same copy serves every device running that model, so only the manager needs internet access.
 
 Set `SHELLY_FIRMWARE_ADVERTISED_BASE_URL` to a URL your devices can reach, for example `http://192.168.1.50:8000`. There is no default and a local update fails immediately without it, because the manager cannot work out its own device-facing address. The devices fetch that URL unauthenticated, so it has to be reachable from the device network.
 

packages/api/README.md

@@ -69,8 +69,10 @@ POST /api/devices/{ip}/update      # Update device firmware
 
 POST /api/devices/{ip}/reboot      # Reboot device
 
-POST /api/devices/bulk/update      # Bulk firmware updates
-  # Body: {"device_ips": ["192.168.1.100", "192.168.1.101"], "channel": "stable"}
+POST /api/devices/bulk             # Bulk operations (update, reboot, factory_reset)
+  # Body: {"device_ips": ["192.168.1.100", "192.168.1.101"], "operation": "update",
+  #        "channel": "stable", "source": "internet"}
+  #   update takes the same channel and source fields as the single-device route
 
 # Component Actions
 GET /api/devices/{ip}/components/actions           # Discover available actions
@@ -244,7 +246,7 @@ curl -X POST http://localhost:8000/api/devices/192.168.1.100/update \
 
 For a device with no internet access, ask the manager to serve the firmware.
 It downloads the official bundle once, keeps it, and hands the device a URL on
-this host. Requires `SHELLY_FIRMWARE_ADVERTISED_BASE_URL`; stable channel only.
+this host. Requires `SHELLY_FIRMWARE_ADVERTISED_BASE_URL`.
 
 ```bash
 curl -X POST http://localhost:8000/api/devices/192.168.1.100/update \

packages/api/src/api/controllers/devices.py

@@ -397,7 +397,9 @@ async def execute_bulk_operations(
     returned for each device individually.
 
     Args:
-        data: Request containing device_ips list and operation type
+        data: Request containing device_ips list, operation type, and for
+            updates an optional "channel" (stable/beta) and "source"
+            (internet/local, default internet)
 
     Returns:
         list[dict]: Operation results for each device with success status
@@ -424,9 +426,20 @@ async def execute_bulk_operations(
 
     if operation == "update":
         channel = data.get("channel", "stable")
-        results = await bulk_operations_use_case.execute_bulk_update(
-            device_ips, channel
-        )
+        source = data.get("source", "internet")
+        if source not in ("internet", "local"):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unsupported source: {source}. Supported: internet, local",
+            )
+        if source == "local":
+            results = await bulk_operations_use_case.execute_bulk_local_update(
+                device_ips, channel
+            )
+        else:
+            results = await bulk_operations_use_case.execute_bulk_update(
+                device_ips, channel
+            )
     elif operation == "reboot":
         results = await bulk_operations_use_case.execute_bulk_reboot(device_ips)
     elif operation == "factory_reset":

packages/api/tests/unit/controllers/test_devices.py

@@ -571,6 +571,109 @@ def __init__(self):
 
             assert response.status_code == 400
 
+    def test_bulk_operations_update_via_local_source(self):
+        from core.use_cases.bulk_operations import BulkOperationsUseCase
+
+        class MockBulkOperationsUseCase(BulkOperationsUseCase):
+            def __init__(self):
+                pass
+
+            async def execute_bulk_update(self, device_ips, channel="stable"):
+                raise AssertionError("local source must not use the device path")
+
+            async def execute_bulk_local_update(self, device_ips, channel="stable"):
+                return [
+                    ActionResult(
+                        device_ip=ip,
+                        success=True,
+                        message=f"Updating to {channel}",
+                        action_type="shelly.Update",
+                    )
+                    for ip in device_ips
+                ]
+
+        with create_test_client(
+            route_handlers=[execute_bulk_operations],
+            dependencies={
+                "bulk_operations_use_case": Provide(
+                    lambda: MockBulkOperationsUseCase(), sync_to_thread=False
+                )
+            },
+        ) as client:
+            response = client.post(
+                "/bulk",
+                json={
+                    "device_ips": ["192.168.1.100", "192.168.1.101"],
+                    "operation": "update",
+                    "channel": "beta",
+                    "source": "local",
+                },
+            )
+
+            assert response.status_code == 200
+            data = response.json()
+            assert len(data) == 2
+            assert all(result["success"] for result in data)
+            assert all(result["source"] == "local" for result in data)
+            assert all(result["channel"] == "beta" for result in data)
+
+    def test_bulk_operations_local_update_reports_missing_configuration(self):
+        from core.domain.entities.exceptions import FirmwareConfigurationError
+        from core.use_cases.bulk_operations import BulkOperationsUseCase
+
+        class MockBulkOperationsUseCase(BulkOperationsUseCase):
+            def __init__(self):
+                pass
+
+            async def execute_bulk_local_update(self, device_ips, channel="stable"):
+                raise FirmwareConfigurationError("Advertised base URL unset")
+
+        with create_test_client(
+            route_handlers=[execute_bulk_operations],
+            dependencies={
+                "bulk_operations_use_case": Provide(
+                    lambda: MockBulkOperationsUseCase(), sync_to_thread=False
+                )
+            },
+            exception_handlers=EXCEPTION_HANDLERS,
+        ) as client:
+            response = client.post(
+                "/bulk",
+                json={
+                    "device_ips": ["192.168.1.100"],
+                    "operation": "update",
+                    "source": "local",
+                },
+            )
+
+            assert response.status_code == 500
+
+    def test_bulk_operations_update_rejects_an_unknown_source(self):
+        from core.use_cases.bulk_operations import BulkOperationsUseCase
+
+        class MockBulkOperationsUseCase(BulkOperationsUseCase):
+            def __init__(self):
+                pass
+
+        with create_test_client(
+            route_handlers=[execute_bulk_operations],
+            dependencies={
+                "bulk_operations_use_case": Provide(
+                    lambda: MockBulkOperationsUseCase(), sync_to_thread=False
+                )
+            },
+        ) as client:
+            response = client.post(
+                "/bulk",
+                json={
+                    "device_ips": ["192.168.1.100"],
+                    "operation": "update",
+                    "source": "cloud",
+                },
+            )
+
+            assert response.status_code == 400
+
     def test_bulk_operations_reboot_successfully(self):
         from core.use_cases.bulk_operations import BulkOperationsUseCase
 

packages/cli/README.md

@@ -161,7 +161,7 @@ With `--source local` the manager downloads the official firmware once and the
 device fetches it from the manager, so only this host needs internet access.
 It reads the same firmware store as the API and requires
 `SHELLY_FIRMWARE_ADVERTISED_BASE_URL` to be set to a URL your devices can
-reach; the API must serve that URL. Stable channel only.
+reach; the API must serve that URL.
 
 ### Configuration Management
 

packages/cli/src/cli/commands/device_commands.py

@@ -15,7 +15,7 @@
     DeviceScanRequest,
     DeviceStatusRequest,
 )
-from ..exceptions import EXIT_USAGE, EXIT_VALIDATION
+from ..exceptions import EXIT_VALIDATION
 from ..presentation.styles import Messages
 from ..use_cases.device.component_actions import ComponentActionsUseCase
 from ..use_cases.device.device_status import DeviceStatusUseCase
@@ -340,12 +340,6 @@ async def update_firmware(
       shelly-manager device update 192.168.1.0/24 --channel beta
       shelly-manager device update -t 192.168.1.100 --source local
     """
-    if source == "local" and channel != UpdateChannel.STABLE.value:
-        ctx.obj.console.print(
-            Messages.error("Local updates support the stable channel only")
-        )
-        sys.exit(EXIT_USAGE)
-
     request = ComponentActionRequest(
         targets=list(targets) + list(targets_opt),
         component_key="shelly",
@@ -362,6 +356,7 @@ async def update_firmware(
         "shelly-manager device update -t 192.168.1.100",
         "shelly-manager device update 192.168.1.0/24 --channel beta",
         from_local_store=source == "local",
+        channel=channel,
     )
 
 
@@ -416,21 +411,21 @@ async def _run_component_action(
     request: ComponentActionRequest,
     *examples: str,
     from_local_store: bool = False,
+    channel: str = "stable",
 ) -> None:
     """Run one component action across every requested device.
 
     ``from_local_store`` serves a firmware update out of this host's own
-    firmware store rather than leaving each device to fetch from the internet.
+    firmware store rather than leaving each device to fetch from the
+    internet; ``channel`` picks the release it serves.
     """
     console = ctx.obj.console
     actions_use_case = ComponentActionsUseCase(ctx.obj.container, console)
-    execute = (
-        actions_use_case.execute_local_update
-        if from_local_store
-        else actions_use_case.execute_action
-    )
     try:
-        results = await execute(request)
+        if from_local_store:
+            results = await actions_use_case.execute_local_update(request, channel)
+        else:
+            results = await actions_use_case.execute_action(request)
     except ValueError as e:
         _print_usage_error(console, e, *examples)
         sys.exit(EXIT_VALIDATION)

packages/cli/src/cli/use_cases/device/component_actions.py

@@ -133,7 +133,7 @@ async def execute_action(
         return results
 
     async def execute_local_update(
-        self, request: ComponentActionRequest
+        self, request: ComponentActionRequest, channel: str = "stable"
     ) -> list[ComponentActionResult]:
         """Update devices with firmware served from the manager's local store.
 
@@ -184,7 +184,7 @@ async def execute_local_update(
             for device_ip in device_ips:
                 try:
                     action_result = await update_interactor.execute(
-                        BaseDeviceRequest(device_ip=device_ip)
+                        BaseDeviceRequest(device_ip=device_ip), channel
                     )
 
                     result = ComponentActionResult(

packages/cli/tests/unit/commands/test_device_commands.py

@@ -583,28 +583,52 @@ def test_device_update_local_source(self, cli_context, sample_device):
 
         assert result.exit_code == 0
         mock_local_interactor.execute.assert_called_once()
-        request = mock_local_interactor.execute.call_args.args[0]
+        request, channel = mock_local_interactor.execute.call_args.args
         assert request.device_ip == sample_device.ip
+        assert channel == "stable"
+
+    def test_device_update_local_source_passes_the_beta_channel(
+        self, cli_context, sample_device
+    ):
+        """Test that a beta local update reaches the interactor with its channel."""
+        from core.domain.value_objects.action_result import ActionResult
+
+        mock_scan_interactor = cli_context.container.get_scan_interactor.return_value
+        mock_scan_interactor.execute.return_value = [sample_device]
+        cli_context.container.initialize_database = AsyncMock()
+
+        mock_local_interactor = AsyncMock()
+        mock_local_interactor.execute.return_value = ActionResult(
+            device_ip=sample_device.ip,
+            action_type="shelly.Update",
+            success=True,
+            message="Update executed successfully on shelly",
+        )
+        cli_context.container.get_update_device_from_local_interactor.return_value = (
+            mock_local_interactor
+        )
 
-    def test_device_update_local_source_rejects_beta(self, cli_context):
-        """Test that a beta local update is refused."""
         runner = CliRunner()
         result = runner.invoke(
             device_commands,
             [
                 "update",
                 "-t",
-                "192.168.1.100",
+                sample_device.ip,
                 "--source",
                 "local",
                 "--channel",
                 "beta",
+                "--force",
             ],
             obj=cli_context,
         )
 
-        assert result.exit_code != 0
-        cli_context.container.get_update_device_from_local_interactor.assert_not_called()
+        assert result.exit_code == 0
+        mock_local_interactor.execute.assert_called_once()
+        request, channel = mock_local_interactor.execute.call_args.args
+        assert request.device_ip == sample_device.ip
+        assert channel == "beta"
 
     def test_actions_execute_help(self, cli_context):
         """Test actions execute command help."""

packages/core/src/core/dependencies/container_base.py

@@ -210,7 +210,8 @@ def get_status_interactor(self) -> CheckDeviceStatusUseCase:
     def get_bulk_operations_interactor(self) -> BulkOperationsUseCase:
         if self._bulk_operations_interactor is None:
             self._bulk_operations_interactor = BulkOperationsUseCase(
-                device_gateway=self.get_device_gateway()
+                device_gateway=self.get_device_gateway(),
+                update_device_from_local=self.get_update_device_from_local_interactor(),
             )
         return self._bulk_operations_interactor