docs: void loadHandlers(ControllerAddress address) throws CommandLineException, CommandLineParserException {
  
          ModelControllerClient client = ctx.getModelControllerClient();
          assert client != null : "client is null";
  
          if(moduleLoader == null) {
              ctx.printLine("Warning! The CLI is running in a non-modular environment and cannot load commands from management extensions.");
              return;
          }
  
          if(address != null && currentAddress != null && address.equals(currentAddress)) {
              return;
          }
  
          // remove previously loaded commands
          resetHandlers();
          currentAddress = address;
  
          final ModelNode req = new ModelNode();
          req.get(Util.ADDRESS).setEmptyList();
          req.get(Util.OPERATION).set(Util.READ_CHILDREN_RESOURCES);
          req.get(Util.CHILD_TYPE).set(Util.EXTENSION);
  
          final ModelNode response;
          try {
              response = client.execute(req);
          } catch (IOException e) {
              throw new CommandLineException("Extensions loader failed to read extensions", e);
          }
  
          if(!Util.isSuccess(response)) {
              throw new CommandLineException("Extensions loader failed to read extensions: " + Util.getFailureDescription(response));
          }
  
          final ModelNode result = response.get(Util.RESULT);
          if(!result.isDefined()) {
              throw new CommandLineException("Extensions loader failed to read extensions: " + result.asString());
          }
  
          for(Property ext : result.asPropertyList()) {
              ModelNode module = ext.getValue().get(Util.MODULE);
              if(!module.isDefined()) {
                  addError("Extension " + ext.getName() + " is missing module attribute");
              } else {
                  final ModuleIdentifier moduleId = ModuleIdentifier.fromString(module.asString());
                  ModuleClassLoader cl;
                  try {
                      cl = moduleLoader.loadModule(moduleId).getClassLoader();
                      ServiceLoader<CommandHandlerProvider> loader = ServiceLoader.load(CommandHandlerProvider.class, cl);
                      for (CommandHandlerProvider provider : loader) {
                          try {
                              registry.registerHandler(provider.createCommandHandler(ctx), provider.isTabComplete(), provider.getNames());
                              addHandlers(Arrays.asList(provider.getNames()));
                          } catch(CommandRegistry.RegisterHandlerException e) {
                              addError(e.getLocalizedMessage());
                              final List<String> addedCommands = new ArrayList<String>(Arrays.asList(provider.getNames()));
                              addedCommands.removeAll(e.getNotAddedNames());
                              addHandlers(addedCommands);
                          }
                      }
                      ServiceLoader<Command> loader2 = ServiceLoader.load(Command.class, cl);
                      for (Command provider : loader2) {
                          try {
                              CommandContainer container = aeshRegistry.addCommand(provider);
                              addCommand(container.getParser().getProcessedCommand().name());
                          } catch (CommandLineException e) {
                              addError(e.getLocalizedMessage());
                          }
                      }
                  } catch (ModuleLoadException e) {
                      addError("Module " + module.asString() + " from extension " + ext.getName() +
                              " available on the server couldn't be loaded locally: " + e.getLocalizedMessage());
                  }
              }
          }
  
          if(!errors.isEmpty()) {
              ctx.printLine("Warning! There were errors trying to load extensions. For more details, please, execute 'extension-commands --errors'");
          }
      }