feat(sync): enable-all group + stop after break (#30)

* feat(sync): add enable-all and stop players after break

Replace multi-step Apple Shortcuts with `sync enable <primary>` (group every other player) and clear leftover AirPlay/capture on `sync break` by stopping freed secondaries and empty primaries.

* fix(sync): resolve mypy optional slave reassignment in create

---------

Co-authored-by: Tim Baur <tbaur@users.noreply.github.com>

Author: tbaur

cli.py

@@ -95,8 +95,9 @@ def print_help(self) -> None:
 
         print(f"{BOLD}Presets & Sync:{RESET}")
         print(f"  {GREEN}presets{RESET}  {DIM}[name] [id]{RESET}               List or play a preset")
+        print(f"  {GREEN}sync{RESET}    {DIM}enable <primary>{RESET}           Group all others under primary")
         print(f"  {GREEN}sync{RESET}    {DIM}create <master> <slaves>{RESET}   Create sync group")
-        print(f"  {GREEN}sync{RESET}    {DIM}break [name]{RESET}               Break sync group")
+        print(f"  {GREEN}sync{RESET}    {DIM}break [name]{RESET}               Break sync group (stops freed players)")
         print(f"  {GREEN}sync{RESET}    {DIM}list{RESET}                       Show sync groups\n")
 
         print(f"{BOLD}System:{RESET}")
@@ -813,7 +814,43 @@ def sync(self, args) -> None:
         """Manage sync groups."""
         action = args.action
 
-        if action == 'create':
+        if action == 'enable':
+            primary_name = args.master
+            if not primary_name:
+                print(f"{RED}Usage: sync enable <primary-name>{RESET}")
+                return
+
+            all_devices = self._get_matching_devices(None)
+            devices = {d.name.lower(): d for d in all_devices}
+            master = devices.get(primary_name.lower())
+            if not master:
+                # Allow substring match like other commands
+                matches = [d for d in all_devices if primary_name.lower() in d.name.lower()]
+                if len(matches) == 1:
+                    master = matches[0]
+                elif len(matches) > 1:
+                    print(f"{RED}Primary '{primary_name}' is ambiguous:{RESET}")
+                    for d in matches:
+                        print(f"  - {d.name}")
+                    return
+                else:
+                    print(f"{RED}Primary device '{primary_name}' not found.{RESET}")
+                    return
+
+            slaves = [d for d in all_devices if d.ip != master.ip]
+            if not slaves:
+                print(f"{YELLOW}No other players to group under {master.name}.{RESET}")
+                return
+
+            print(f"\n{BOLD}Enabling runtime group: {master.name} leads {len(slaves)} player(s)...{RESET}")
+            print("-" * 40)
+            for slave in sorted(slaves, key=lambda d: d.name.lower()):
+                res = self.ctl.add_sync_slave(master.ip, slave.ip)
+                state = f"{GREEN}ADDED{RESET}" if res else f"{RED}ERROR{RESET}"
+                print(f"[{state}] {slave.name} -> {master.name}")
+            print()
+
+        elif action == 'create':
             master_name = args.master
             slave_names = args.slaves.split(',') if args.slaves else []
 
@@ -829,11 +866,11 @@ def sync(self, args) -> None:
             print("-" * 40)
 
             for slave_name in slave_names:
-                slave = devices.get(slave_name.strip().lower())
-                if slave:
-                    res = self.ctl.add_sync_slave(master.ip, slave.ip)
+                slave_dev = devices.get(slave_name.strip().lower())
+                if slave_dev:
+                    res = self.ctl.add_sync_slave(master.ip, slave_dev.ip)
                     state = f"{GREEN}ADDED{RESET}" if res else f"{RED}ERROR{RESET}"
-                    print(f"[{state}] {slave.name} -> {master.name}")
+                    print(f"[{state}] {slave_dev.name} -> {master.name}")
                 else:
                     print(f"{YELLOW}Slave '{slave_name}' not found.{RESET}")
             print()
@@ -856,10 +893,22 @@ def sync(self, args) -> None:
 
             print(f"\n{BOLD}Breaking sync groups...{RESET}")
             print("-" * 40)
+            primary_ips: set[str] = set()
             for master_ip, slave_ip, label in operations:
                 success = self.ctl.remove_sync_slave(master_ip, slave_ip)
                 state = f"{GREEN}BROKEN{RESET}" if success else f"{RED}ERROR{RESET}"
                 print(f"[{state}] {label}")
+                if success:
+                    # Clear leftover AirPlay/capture on freed secondaries.
+                    self.ctl.stop(slave_ip)
+                    primary_ips.add(master_ip)
+
+            for master_ip in sorted(primary_ips):
+                primary = self.ctl.get_device_info(master_ip)
+                if not primary.slaves:
+                    self.ctl.stop(master_ip)
+                    name = primary.name if primary.name != "Unknown" else master_ip
+                    print(f"[{GREEN}STOPPED{RESET}] {name} (cleared capture)")
             print()
 
         elif action == 'list':

main.py

@@ -296,8 +296,17 @@ def main() -> None:
 
     # Sync groups
     sync_cmd = sub.add_parser("sync")
-    sync_cmd.add_argument("action", choices=["create", "break", "list"])
-    sync_cmd.add_argument("master", nargs="?", default=None, help="Master device (for create)")
+    sync_cmd.add_argument(
+        "action",
+        choices=["enable", "create", "break", "list"],
+        help="enable: group all others under primary; create/break/list as before",
+    )
+    sync_cmd.add_argument(
+        "master",
+        nargs="?",
+        default=None,
+        help="Primary/master device name (enable, create) or break target",
+    )
     sync_cmd.add_argument("slaves", nargs="?", default=None, help="Slave devices, comma-separated (for create)")
     sync_cmd.add_argument("target", nargs="?", default=None, help="Target device (for break)")
     sync_cmd.add_argument("--scan", action="store_true", help="Force network rescan before command")

tests/test_cli_coverage.py

@@ -234,9 +234,22 @@ def test_sync_break(self, cli):
                 mock_executor_class.return_value = mock_executor
 
                 with patch.object(cli.ctl, 'remove_sync_slave', return_value=True) as mock_remove:
-                    with patch('builtins.print'):
-                        cli.sync(args)
+                    with patch.object(cli.ctl, 'stop', return_value=True) as mock_stop:
+                        with patch.object(
+                            cli.ctl,
+                            'get_device_info',
+                            return_value=PlayerStatus(
+                                ip="192.168.1.100",
+                                name="Living Room",
+                                slaves=[],
+                            ),
+                        ):
+                            with patch('builtins.print'):
+                                cli.sync(args)
                     mock_remove.assert_called_once_with("192.168.1.100", "192.168.1.101")
+                    assert mock_stop.call_count == 2
+                    mock_stop.assert_any_call("192.168.1.101")
+                    mock_stop.assert_any_call("192.168.1.100")
 
     def test_sync_break_with_master_arg(self, cli):
         """Test sync break accepts device name in master positional arg."""
@@ -250,9 +263,39 @@ def test_sync_break_with_master_arg(self, cli):
 
         with patch.object(cli, '_get_matching_devices', side_effect=[[primary, slave], [slave]]):
             with patch.object(cli.ctl, 'remove_sync_slave', return_value=True) as mock_remove:
+                with patch.object(cli.ctl, 'stop', return_value=True):
+                    with patch.object(
+                        cli.ctl,
+                        'get_device_info',
+                        return_value=PlayerStatus(
+                            ip="192.168.1.100",
+                            name="Living Room",
+                            slaves=[],
+                        ),
+                    ):
+                        with patch('builtins.print'):
+                            cli.sync(args)
+                mock_remove.assert_called_once_with("192.168.1.100", "192.168.1.101")
+
+    def test_sync_enable_groups_all_others(self, cli):
+        """sync enable adds every other player under the primary."""
+        primary = PlayerStatus(ip="192.168.1.100", name="Living Room Speakers")
+        kitchen = PlayerStatus(ip="192.168.1.101", name="Kitchen Speakers")
+        patio = PlayerStatus(ip="192.168.1.102", name="Patio Speakers")
+
+        args = MagicMock()
+        args.action = 'enable'
+        args.master = 'Living Room Speakers'
+        args.slaves = None
+        args.target = None
+
+        with patch.object(cli, '_get_matching_devices', return_value=[primary, kitchen, patio]):
+            with patch.object(cli.ctl, 'add_sync_slave', return_value=True) as mock_add:
                 with patch('builtins.print'):
                     cli.sync(args)
-                mock_remove.assert_called_once_with("192.168.1.100", "192.168.1.101")
+                assert mock_add.call_count == 2
+                mock_add.assert_any_call("192.168.1.100", "192.168.1.101")
+                mock_add.assert_any_call("192.168.1.100", "192.168.1.102")
 
     def test_sync_list_no_ips(self, cli):
         """Test sync list warns when no devices discovered."""