From 1b8ebaa128a0522a39ad0d6cb9451331fa207d06 Mon Sep 17 00:00:00 2001
From: Stephane Janel <stephane.janel@amadeus.com>
Date: Sat, 30 Sep 2023 18:22:46 +0200
Subject: [PATCH] Support multi command in CLI, with commands starting without
 -- (for instance, 'trade' instead of '--trade')

---
 src/engine/include/coincentercommands.hpp     |  10 +-
 src/engine/include/coincenteroptions.hpp      | 173 +++++++++---------
 src/engine/include/commandlineoption.hpp      |  14 +-
 .../include/commandlineoptionsparser.hpp      | 146 +++++++++------
 src/engine/src/coincentercommands.cpp         |  47 +++--
 .../src/commandlineoptionsparseriterator.hpp  |  60 ++++++
 .../test/commandlineoptionsparser_test.cpp    |  76 ++++----
 src/main/src/main.cpp                         |   9 +-
 src/main/src/processcommandsfromcli.cpp       |   6 +-
 src/main/src/processcommandsfromcli.hpp       |   2 +-
 10 files changed, 326 insertions(+), 217 deletions(-)
 create mode 100644 src/engine/src/commandlineoptionsparseriterator.hpp

diff --git a/src/engine/include/coincentercommands.hpp b/src/engine/include/coincentercommands.hpp
index a504a9ea..73cff34b 100644
--- a/src/engine/include/coincentercommands.hpp
+++ b/src/engine/include/coincentercommands.hpp
@@ -17,13 +17,17 @@ class CoincenterCommands {
   CoincenterCommands() noexcept(std::is_nothrow_default_constructible_v<Commands>) = default;
 
   // Builds a CoincenterCommands and add commands from given command line options.
-  explicit CoincenterCommands(const CoincenterCmdLineOptions &cmdLineOptions);
+  explicit CoincenterCommands(const CoincenterCmdLineOptions &cmdLineOptions)
+      : CoincenterCommands(std::span<const CoincenterCmdLineOptions>{&cmdLineOptions, 1U}) {}
 
-  static CoincenterCmdLineOptions ParseOptions(int argc, const char *argv[]);
+  // Builds a CoincenterCommands and add commands from given command line options span.
+  explicit CoincenterCommands(std::span<const CoincenterCmdLineOptions> cmdLineOptionsSpan);
+
+  static vector<CoincenterCmdLineOptions> ParseOptions(int argc, const char *argv[]);
 
   /// @brief Set this CoincenterCommands from given command line options.
   /// @return false if only help or version is asked, true otherwise
-  bool setFromOptions(const CoincenterCmdLineOptions &cmdLineOptions);
+  bool addOption(const CoincenterCmdLineOptions &cmdLineOptions);
 
   std::span<const CoincenterCommand> commands() const { return _commands; }
 
diff --git a/src/engine/include/coincenteroptions.hpp b/src/engine/include/coincenteroptions.hpp
index 118bd8d9..6467a36a 100644
--- a/src/engine/include/coincenteroptions.hpp
+++ b/src/engine/include/coincenteroptions.hpp
@@ -223,9 +223,9 @@ struct CoincenterAllowedOptions {
   using CommandLineOptionWithValue = typename AllowedCommandLineOptionsBase<OptValueType>::CommandLineOptionWithValue;
 
   static constexpr CommandLineOptionWithValue value[] = {
-      {{{"General", 1}, "--help", 'h', "", "Display this information"}, &OptValueType::help},
-      {{{"General", 2}, "--data", "<path/to/data>", CoincenterCmdLineOptions::kData}, &OptValueType::dataDir},
-      {{{"General", 3},
+      {{{"General", 10}, "help", 'h', "", "Display this information"}, &OptValueType::help},
+      {{{"General", 20}, "--data", "<path/to/data>", CoincenterCmdLineOptions::kData}, &OptValueType::dataDir},
+      {{{"General", 30},
         "--log",
         'v',
         "<levelName|0-6>",
@@ -233,21 +233,21 @@ struct CoincenterAllowedOptions {
         "Possible values are: (off|critical|error|warning|info|debug|trace) or "
         "(0-6) (overrides .log.console in general config file)"},
        &OptValueType::logConsole},
-      {{{"General", 4}, "--log-console", "<levelName|0-6>", "Synonym of --log"}, &OptValueType::logConsole},
-      {{{"General", 4},
+      {{{"General", 40}, "--log-console", "<levelName|0-6>", "Synonym of --log"}, &OptValueType::logConsole},
+      {{{"General", 40},
         "--log-file",
         "<levelName|0-6>",
         "Sets the log level in files during all execution (overrides .log.file in general config file). "
         "Number of rotating files to keep and their size is configurable in the general config file"},
        &OptValueType::logFile},
-      {{{"General", 5}, "--output", 'o', "", CoincenterCmdLineOptions::kOutput}, &OptValueType::apiOutputType},
-      {{{"General", 7},
+      {{{"General", 50}, "--output", 'o', "", CoincenterCmdLineOptions::kOutput}, &OptValueType::apiOutputType},
+      {{{"General", 70},
         "--no-secrets",
         "<[exch1,...]>",
         "Do not load secrets for specified exchanges.\n"
         "If no exchange is specified, no key will be loaded at all"},
        &OptValueType::noSecrets},
-      {{{"General", 8},
+      {{{"General", 80},
         "--repeat",
         'r',
         "<[n]>",
@@ -255,151 +255,144 @@ struct CoincenterAllowedOptions {
         "Modifying requests such as trades and withdraws are not impacted by this option. "
         "This is useful for monitoring for instance. 'n' is optional, if not given, will repeat endlessly"},
        &OptValueType::repeats},
-      {{{"General", 9}, "--repeat-time", "<time>", CoincenterCmdLineOptions::kRepeat}, &OptValueType::repeatTime},
-      {{{"General", 10}, "--version", "", "Display program version"}, &OptValueType::version},
-      {{{"Public queries", 20},
-        "--health-check",
+      {{{"General", 90}, "--repeat-time", "<time>", CoincenterCmdLineOptions::kRepeat}, &OptValueType::repeatTime},
+      {{{"General", 100}, "version", "", "Display program version"}, &OptValueType::version},
+      {{{"Public queries", 200},
+        "health-check",
         "<[exch1,...]>",
         "Simple health check for all exchanges or specified ones"},
        &OptValueType::healthCheck},
-      {{{"Public queries", 20},
-        "--markets",
-        'm',
+      {{{"Public queries", 210},
+        "markets",
         "<cur1[-cur2][,exch1,...]>",
         "Print markets involving given currencies for all exchanges, "
         "or only the specified ones. "
         "Either a single currency or a full market can be specified."},
        &OptValueType::markets},
 
-      {{{"Public queries", 20},
-        "--orderbook",
+      {{{"Public queries", 220},
+        "orderbook",
         "<cur1-cur2[,exch1,...]>",
         "Print order book of currency pair for all exchanges offering "
         "this market, or only for specified exchanges."},
        &OptValueType::orderbook},
-      {{{"Public queries", 20}, "--orderbook-depth", "<n>", "Override default depth of order book"},
-       &OptValueType::orderbookDepth},
-      {{{"Public queries", 20},
+      {{{"Public queries", 230},
         "--orderbook-cur",
         "<cur>",
         "If conversion of cur2 into cur is possible (for each exchange), "
         "prints additional column converted to given asset"},
        &OptValueType::orderbookCur},
-      {{{"Public queries", 20},
-        "--ticker",
+      {{{"Public queries", 230}, "--orderbook-depth", "<n>", "Override default depth of order book"},
+       &OptValueType::orderbookDepth},
+      {{{"Public queries", 240},
+        "ticker",
         "<[exch1,...]>",
         "Print ticker information for all markets for all exchanges,"
         " or only for specified ones"},
        &OptValueType::ticker},
-      {{{"Public queries", 20},
-        "--conversion",
-        'c',
+      {{{"Public queries", 250},
+        "conversion",
         "<cur1-cur2[,exch1,...]>",
         "Print fastest conversion path of 'cur1' to 'cur2' "
         "for given exchanges if possible"},
        &OptValueType::conversionPath},
-      {{{"Public queries", 20},
-        "--volume-day",
+      {{{"Public queries", 260},
+        "volume-day",
         "<cur1-cur2[,exch1,...]>",
         "Print last 24h traded volume for market 'cur1'-'cur2' "
         "for all exchanges (or specified one)"},
        &OptValueType::last24hTradedVolume},
-      {{{"Public queries", 20},
-        "--last-trades",
+      {{{"Public queries", 270},
+        "last-trades",
         "<cur1-cur2[,exch1,...]>",
         "Print last trades for market 'cur1'-'cur2' "
         "for all exchanges (or specified one)"},
        &OptValueType::lastTrades},
-      {{{"Public queries", 20}, "--last-trades-n", "<n>", CoincenterCmdLineOptions::kLastTradesN},
+      {{{"Public queries", 280}, "--last-trades-n", "<n>", CoincenterCmdLineOptions::kLastTradesN},
        &OptValueType::nbLastTrades},
-      {{{"Public queries", 20},
-        "--price",
-        'p',
+      {{{"Public queries", 290},
+        "price",
         "<cur1-cur2[,exch1,...]>",
         "Print last price for market 'cur1'-'cur2' "
         "for all exchanges (or specified one)"},
        &OptValueType::lastPrice},
 
-      {{{"Private queries", 30},
-        "--balance",
-        'b',
+      {{{"Private queries", 300},
+        "balance",
         "<[cur][,exch1,...]>",
         "Prints sum of available balance for all selected accounts, "
         "or all if none given. Optional acronym can be provided, "
         "in this case a total amount will be printed in this currency "
         "if conversion is possible."},
        &OptValueType::balance},
-      {{{"Private queries", 30}, "--balance-in-use", "", "Include balance in use as well from opened orders"},
+      {{{"Private queries", 310}, "--balance-in-use", "", "Include balance in use as well from opened orders"},
        &OptValueType::withBalanceInUse},
-      {{{"Private queries", 30},
-        "--orders-opened",
+      {{{"Private queries", 320},
+        "orders-opened",
         "<cur1-cur2[,exch1,...]>",
         "Print opened orders matching selection criteria.\n"
         "All cur1, cur2 and exchanges are optional, "
         "returned opened orders will be filtered accordingly."},
        &OptValueType::openedOrdersInfo},
-      {{{"Private queries", 31},
-        "--orders-cancel",
+      {{{"Private queries", 320},
+        "orders-cancel",
         "<cur1-cur2[,exch1,...]>",
         "Cancel opened orders matching selection criteria.\n"
         "All cur1, cur2 and exchanges are optional."},
        &OptValueType::cancelOpenedOrders},
-      {{{"Private queries", 31},
+      {{{"Private queries", 320},
         "--orders-id",
         "<id1,...>",
         "Only select orders with given ID.\n"
         "One or several IDs can be given, should be comma separated."},
        &OptValueType::ordersIds},
-      {{{"Private queries", 31}, "--orders-min-age", "<time>", "Only select orders with given minimum age."},
+      {{{"Private queries", 320}, "--orders-min-age", "<time>", "Only select orders with given minimum age."},
        &OptValueType::ordersMinAge},
-      {{{"Private queries", 32}, "--orders-max-age", "<time>", "Only select orders with given maximum age."},
+      {{{"Private queries", 330}, "--orders-max-age", "<time>", "Only select orders with given maximum age."},
        &OptValueType::ordersMaxAge},
-      {{{"Private queries", 33},
-        "--deposits",
-        'd',
+      {{{"Private queries", 340},
+        "deposits",
         "<cur[,exch1,...]>",
         "Print recent deposits matching selection criteria.\n"
         "Currency and exchanges are optional, "
         "returned deposits will be filtered accordingly."},
        &OptValueType::recentDepositsInfo},
-      {{{"Private queries", 33},
+      {{{"Private queries", 350},
         "--deposits-id",
         "<id1,...>",
         "Only select deposits with given ID.\n"
         "One or several IDs can be given, should be comma separated."},
        &OptValueType::depositsIds},
-      {{{"Private queries", 33}, "--deposits-min-age", "<time>", "Only select deposits with given minimum age."},
+      {{{"Private queries", 360}, "--deposits-min-age", "<time>", "Only select deposits with given minimum age."},
        &OptValueType::depositsMinAge},
-      {{{"Private queries", 33}, "--deposits-max-age", "<time>", "Only select deposits with given maximum age."},
+      {{{"Private queries", 370}, "--deposits-max-age", "<time>", "Only select deposits with given maximum age."},
        &OptValueType::depositsMaxAge},
-      {{{"Private queries", 34},
-        "--withdraws",
-        'w',
+      {{{"Private queries", 380},
+        "withdraws",
         "<cur[,exch1,...]>",
         "Print recent withdraws matching selection criteria.\n"
         "Currency and exchanges are optional, "
         "returned withdraws will be filtered accordingly."},
        &OptValueType::recentWithdrawsInfo},
-      {{{"Private queries", 34},
+      {{{"Private queries", 390},
         "--withdraws-id",
         "<id1,...>",
         "Only select withdraws with given ID.\n"
         "One or several IDs can be given, should be comma separated."},
        &OptValueType::withdrawsIds},
-      {{{"Private queries", 34}, "--withdraws-min-age", "<time>", "Only select withdraws with given minimum age."},
+      {{{"Private queries", 391}, "--withdraws-min-age", "<time>", "Only select withdraws with given minimum age."},
        &OptValueType::withdrawsMinAge},
-      {{{"Private queries", 34}, "--withdraws-max-age", "<time>", "Only select withdraws with given maximum age."},
+      {{{"Private queries", 392}, "--withdraws-max-age", "<time>", "Only select withdraws with given maximum age."},
        &OptValueType::withdrawsMaxAge},
-      {{{"Trade", 40}, "--buy", "<amt cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartBuy}, &OptValueType::buy},
-      {{{"Trade", 40}, "--sell", "<amt[%]cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartSell}, &OptValueType::sell},
-      {{{"Trade", 40},
-        "--sell-all",
+      {{{"Trade", 400}, "buy", "<amt cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartBuy}, &OptValueType::buy},
+      {{{"Trade", 400}, "sell", "<amt[%]cur[,exch1,...]>", CoincenterCmdLineOptions::kSmartSell}, &OptValueType::sell},
+      {{{"Trade", 400},
+        "sell-all",
         "<cur[,exch1,...]>",
         "Sell all available amount on matching exchanges (or all if none specified), behaving like sell option."},
        &OptValueType::sellAll},
-      {{{"Trade", 40},
-        "--trade",
-        't',
+      {{{"Trade", 400},
+        "trade",
         "<amt[%]cur1-cur2[,exch1,...]>",
         "Single trade from given start amount on a list of exchanges, "
         "or all that have sufficient balance on cur1 if none provided.\n"
@@ -407,20 +400,20 @@ struct CoincenterAllowedOptions {
         "of available amount on matching exchanges will be traded.\n"
         "Orders will be placed prioritizing accounts with largest amounts, at limit price by default."},
        &OptValueType::trade},
-      {{{"Trade", 40},
-        "--trade-all",
+      {{{"Trade", 400},
+        "trade-all",
         "<cur1-cur2[,exch1,...]>",
         "Single trade from available amount from given currency on a list of exchanges,"
         " or all that have some balance on cur1 if none provided\n"
         "Order will be placed at limit price by default"},
        &OptValueType::tradeAll},
-      {{{"Trade", 40},
+      {{{"Trade", 401},
         "--trade-async",
         "",
         "Asynchronous trade mode. Trade orders will be sent in fire and forget mode, not following their lifetime "
-        "until either match or cancel occurs.\n This option is not compatible with multi trade."},
+        "until either match or cancel occurs.\nThis option is not compatible with multi trade."},
        &OptValueType::tradeAsync},
-      {{{"Trade", 41},
+      {{{"Trade", 401},
         "--multi-trade",
         "",
         "Force activation of multi trade mode for all exchanges, overriding default configuration of config file.\n"
@@ -429,12 +422,12 @@ struct CoincenterAllowedOptions {
         "step (for instance, the trade timeout is related to a single trade, not the series of all trades of a multi "
         "trade)."},
        &OptValueType::forceMultiTrade},
-      {{{"Trade", 42},
+      {{{"Trade", 402},
         "--no-multi-trade",
         "",
         "Force deactivation of multi trade mode for all exchanges, overriding default configuration of config file."},
        &OptValueType::forceSingleTrade},
-      {{{"Trade", 43},
+      {{{"Trade", 403},
         "--trade-price",
         "<n|amt cur>",
         "Manually select trade price, supporting two flavors.\n"
@@ -444,7 +437,7 @@ struct CoincenterAllowedOptions {
         "             Order price will not be continuously updated.\n"
         "This option is not compatible with '--trade-strategy'"},
        &OptValueType::tradePrice},
-      {{{"Trade", 43},
+      {{{"Trade", 403},
         "--trade-strategy",
         "<maker|nibble|taker>",
         "Customize the order price strategy of the trade\n"
@@ -454,64 +447,64 @@ struct CoincenterAllowedOptions {
         "Order price will be continuously updated and recomputed every '--trade-update-price' step time.\n"
         "This option is not compatible with '--trade-price'"},
        &OptValueType::tradeStrategy},
-      {{{"Trade", 43}, "--trade-timeout", "<time>", CoincenterCmdLineOptions::kTradeTimeout},
+      {{{"Trade", 403}, "--trade-timeout", "<time>", CoincenterCmdLineOptions::kTradeTimeout},
        &OptValueType::tradeTimeout},
-      {{{"Trade", 43},
+      {{{"Trade", 403},
         "--trade-timeout-match",
         "",
         "If after the timeout some amount is still not traded,\n"
         "force match by placing a remaining order at market price\n"},
        &OptValueType::tradeTimeoutMatch},
-      {{{"Trade", 43}, "--trade-update-price", "<time>", CoincenterCmdLineOptions::kTradeUpdatePrice},
+      {{{"Trade", 403}, "--trade-update-price", "<time>", CoincenterCmdLineOptions::kTradeUpdatePrice},
        &OptValueType::tradeUpdatePrice},
-      {{{"Trade", 44}, "--trade-sim", "", CoincenterCmdLineOptions::kSimulationMode}, &OptValueType::tradeSim},
-      {{{"Tools", 50}, "--dust-sweeper", "<cur[,exch1,...]>", CoincenterCmdLineOptions::kDustSweeper},
+      {{{"Trade", 403}, "--trade-sim", "", CoincenterCmdLineOptions::kSimulationMode}, &OptValueType::tradeSim},
+      {{{"Tools", 500}, "dust-sweeper", "<cur[,exch1,...]>", CoincenterCmdLineOptions::kDustSweeper},
        &OptValueType::dustSweeper},
-      {{{"Withdraw and deposit", 60},
-        "--deposit-info",
+      {{{"Withdraw and deposit", 600},
+        "deposit-info",
         "<cur[,exch1,...]>",
         "Get deposit wallet information for given currency."
         " If no exchange accounts are given, will query all of them by default"},
        &OptValueType::depositInfo},
-      {{{"Withdraw and deposit", 60}, "--withdraw-apply", "<amt[%]cur,from-to>", CoincenterCmdLineOptions::kWithdraw},
+      {{{"Withdraw and deposit", 600}, "withdraw-apply", "<amt[%]cur,from-to>", CoincenterCmdLineOptions::kWithdraw},
        &OptValueType::withdraw},
-      {{{"Withdraw and deposit", 60},
+      {{{"Withdraw and deposit", 601},
         "--withdraw-async",
         "",
         "Initiate withdraw but do not wait for funds' arrival at destination."},
        &OptValueType::withdrawAsync},
-      {{{"Withdraw and deposit", 60},
+      {{{"Withdraw and deposit", 601},
         "--withdraw-refresh-time",
         "<time>",
         CoincenterCmdLineOptions::kWithdrawRefreshTime},
        &OptValueType::withdrawRefreshTime},
-      {{{"Withdraw and deposit", 60},
-        "--withdraw-apply-all",
+      {{{"Withdraw and deposit", 700},
+        "withdraw-apply-all",
         "<cur,from-to>",
         "Withdraw all available amount instead of a specified amount."},
        &OptValueType::withdrawAll},
-      {{{"Withdraw and deposit", 60},
-        "--withdraw-fee",
+      {{{"Withdraw and deposit", 800},
+        "withdraw-fee",
         "<cur[,exch1,...]>",
         "Prints withdraw fees of given currency on all supported exchanges,"
         " or only for the list of specified ones if provided (comma separated)."},
        &OptValueType::withdrawFee},
-      {{{"Monitoring", 70},
+      {{{"Monitoring", 900},
         "--monitoring",
         "",
         "Progressively send metrics to external instance provided that it's correctly set up "
         "(Prometheus by default). Refer to the README for more information"},
        &OptValueType::useMonitoring},
-      {{{"Monitoring", 70}, "--monitoring-port", "<port>", CoincenterCmdLineOptions::kMonitoringPort},
+      {{{"Monitoring", 900}, "--monitoring-port", "<port>", CoincenterCmdLineOptions::kMonitoringPort},
        &OptValueType::monitoringPort},
-      {{{"Monitoring", 70}, "--monitoring-ip", "<IPv4>", CoincenterCmdLineOptions::kMonitoringIP},
+      {{{"Monitoring", 900}, "--monitoring-ip", "<IPv4>", CoincenterCmdLineOptions::kMonitoringIP},
        &OptValueType::monitoringAddress},
-      {{{"Monitoring", 70},
+      {{{"Monitoring", 900},
         "--monitoring-user",
         "<username>",
         "Specify username of metric gateway instance (default: none)"},
        &OptValueType::monitoringUsername},
-      {{{"Monitoring", 70},
+      {{{"Monitoring", 900},
         "--monitoring-pass",
         "<password>",
         "Specify password of metric gateway instance (default: none)"},
diff --git a/src/engine/include/commandlineoption.hpp b/src/engine/include/commandlineoption.hpp
index 01df64e5..1bf2a9a7 100644
--- a/src/engine/include/commandlineoption.hpp
+++ b/src/engine/include/commandlineoption.hpp
@@ -50,6 +50,8 @@ class CommandLineOption {
   constexpr std::strong_ordering operator<=>(const CommandLineOption& o) const;
 
  private:
+  static constexpr std::string_view kLegacyFullNamePrefixOption = "--";
+
   std::string_view _optionGroupName;
   std::string_view _fullName;
   std::string_view _valueDescription;
@@ -92,9 +94,17 @@ struct AllowedCommandLineOptionsBase {
 
 constexpr bool CommandLineOption::matches(std::string_view optName) const {
   if (optName.size() == 2 && optName.front() == '-' && optName.back() == _shortName) {
-    return true;
+    return true;  // it is a short hand flag
+  }
+  if (optName == _fullName) {
+    return true;  // standard full match
+  }
+  if (optName.starts_with(kLegacyFullNamePrefixOption)) {
+    // backwards compatibility check
+    optName.remove_prefix(kLegacyFullNamePrefixOption.length());
+    return optName == _fullName;
   }
-  return optName == _fullName;
+  return false;
 }
 
 constexpr std::strong_ordering CommandLineOption::operator<=>(const CommandLineOption& o) const {
diff --git a/src/engine/include/commandlineoptionsparser.hpp b/src/engine/include/commandlineoptionsparser.hpp
index a0c740d7..abe982b9 100644
--- a/src/engine/include/commandlineoptionsparser.hpp
+++ b/src/engine/include/commandlineoptionsparser.hpp
@@ -35,57 +35,56 @@ template <class... Ts>
 overloaded(Ts...) -> overloaded<Ts...>;
 
 template <class OptValueType>
-class CommandLineOptionsParser : private OptValueType {
+class CommandLineOptionsParser {
  public:
   // TODO: Once clang implements P0634R3, remove 'typename' here
   using CommandLineOptionType = typename AllowedCommandLineOptionsBase<OptValueType>::CommandLineOptionType;
   using CommandLineOptionWithValue = typename AllowedCommandLineOptionsBase<OptValueType>::CommandLineOptionWithValue;
 
   template <unsigned N>
-  explicit CommandLineOptionsParser(const CommandLineOptionWithValue (&init)[N])
-      : _opts(std::begin(init), std::end(init)) {}
+  explicit CommandLineOptionsParser(const CommandLineOptionWithValue (&init)[N]) {
+    append(init);
+  }
 
   template <unsigned N>
-  void append(const CommandLineOptionWithValue (&opts)[N]) {
-    _opts.append(std::begin(opts), std::end(opts));
+  CommandLineOptionsParser& append(const CommandLineOptionWithValue (&opts)[N]) {
+    auto insertedIt = _opts.insert(_opts.end(), std::begin(opts), std::end(opts));
+    const auto sortFunc = [](const auto& lhs, const auto& rhs) { return lhs.first < rhs.first; };
+    std::sort(insertedIt, _opts.end(), sortFunc);
+    std::inplace_merge(_opts.begin(), insertedIt, _opts.end(), sortFunc);
+    return *this;
   }
 
-  OptValueType parse(std::span<const char*> vargv) {
-    // First register the callbacks
-    for (const CommandLineOptionWithValue& arg : _opts) {
-      registerCallback(arg.first, arg.second);
+  OptValueType parse(std::span<const char*> groupedArguments) {
+    std::map<CommandLineOption, CallbackType> callbacks;
+    OptValueType data;
+    for (const auto& [cmdLineOption, prop] : _opts) {
+      callbacks[cmdLineOption] = registerCallback(cmdLineOption, prop, data);
     }
-
-    vargv = vargv.last(vargv.size() - 1U);  // skip first argument which is program name
-    const int vargvSize = static_cast<int>(vargv.size());
-    for (int idxOpt = 0; idxOpt < vargvSize; ++idxOpt) {
-      const char* argStr = vargv[idxOpt];
+    const int nbArgs = static_cast<int>(groupedArguments.size());
+    for (int argPos = 0; argPos < nbArgs; ++argPos) {
+      std::string_view argStr(groupedArguments[argPos]);
       if (std::ranges::none_of(_opts, [argStr](const auto& opt) { return opt.first.matches(argStr); })) {
         throw invalid_argument("Unrecognized command-line option {}", argStr);
       }
 
-      for (auto& cbk : _callbacks) {
-        cbk.second(idxOpt, vargv);
+      for (auto& callback : callbacks) {
+        callback.second(argPos, groupedArguments);
       }
     }
 
-    return static_cast<OptValueType>(*this);
+    return data;
   }
 
-  OptValueType parse(int argc, const char* argv[]) { return parse(std::span(argv, argc)); }
-
   template <typename StreamType>
-  void displayHelp(std::string_view programName, StreamType& stream) {
-    stream << "usage: " << programName << " <options>" << std::endl;
+  void displayHelp(std::string_view programName, StreamType& stream) const {
+    stream << "usage: " << programName << " <general options> <command(s)>" << std::endl;
     if (_opts.empty()) {
       return;
     }
     stream << "Options:" << std::endl;
 
-    std::ranges::sort(_opts, [](const auto& lhs, const auto& rhs) { return lhs.first < rhs.first; });
-
     int lenFirstRows = 0;
-    static constexpr int kMaxCharLine = 120;
     for (const auto& [opt, pm] : _opts) {
       int lenRows = static_cast<int>(opt.fullName().size() + opt.valueDescription().size() + 1);
       if (opt.hasShortName()) {
@@ -93,12 +92,16 @@ class CommandLineOptionsParser : private OptValueType {
       }
       lenFirstRows = std::max(lenFirstRows, lenRows);
     }
-    std::string_view currentGroup, previousGroup;
+    std::string_view currentGroup;
+    std::string_view previousGroup;
     for (const auto& [opt, pm] : _opts) {
       currentGroup = opt.optionGroupName();
       if (currentGroup != previousGroup) {
         stream << std::endl << ' ' << currentGroup << std::endl;
       }
+      if (opt.fullName()[0] != '-') {
+        stream << std::endl;
+      }
       string firstRowsStr(opt.fullName());
       if (opt.hasShortName()) {
         firstRowsStr.append(", -");
@@ -143,57 +146,82 @@ class CommandLineOptionsParser : private OptValueType {
   }
 
  private:
+  static constexpr int kMaxCharLine = 120;
+
+  template <class>
+  friend class CommandLineOptionsParserIterator;
+
   using CallbackType = std::function<void(int&, std::span<const char*>)>;
 
-  vector<CommandLineOptionWithValue> _opts;
-  std::map<CommandLineOption, CallbackType> _callbacks;
+  [[nodiscard]] bool isOptionValue(std::string_view opt) const {
+    return std::ranges::none_of(
+        _opts, [opt](const CommandLineOptionWithValue& cmdLineOpt) { return cmdLineOpt.first.matches(opt); });
+  }
 
-  static bool IsOptionValue(const char* argv) { return argv[0] != '-' || isdigit(argv[1]); }
+  static bool IsOptionPositiveInt(std::string_view opt) { return std::ranges::all_of(opt, isdigit); }
 
-  void registerCallback(const CommandLineOption& commandLineOption, CommandLineOptionType prop) {
-    _callbacks[commandLineOption] = [this, &commandLineOption, prop](int& idx, std::span<const char*> argv) {
+  static bool IsOptionInt(std::string_view opt) {
+    return ((opt[0] == '-' || opt[0] == '+') && std::all_of(std::next(opt.begin()), opt.end(), isdigit)) ||
+           IsOptionPositiveInt(opt);
+  }
+
+  CallbackType registerCallback(const CommandLineOption& commandLineOption, CommandLineOptionType prop,
+                                OptValueType& data) {
+    return [this, &commandLineOption, prop, &data](int& idx, std::span<const char*> argv) {
       if (commandLineOption.matches(argv[idx])) {
         std::visit(overloaded{
-                       [this](bool OptValueType::*arg) { this->*arg = true; },
-                       [this, &idx, argv, &commandLineOption](int OptValueType::*arg) {
-                         if (idx + 1U < argv.size() && IsOptionValue(argv[idx + 1])) {
-                           const char* beg = argv[idx + 1];
-                           const char* end = beg + strlen(beg);
-                           this->*arg = FromString<int>(std::string_view(beg, end));
-                           ++idx;
-                         } else {
-                           ThrowExpectingValueException(commandLineOption);
+                       // bool value matcher
+                       [this, &data](bool OptValueType::*arg) { data.*arg = true; },
+
+                       // int value matcher
+                       [this, &data, &idx, argv, &commandLineOption](int OptValueType::*arg) {
+                         if (idx + 1U < argv.size()) {
+                           std::string_view nextOpt(argv[idx + 1]);
+                           if (IsOptionInt(nextOpt)) {
+                             data.*arg = FromString<int>(nextOpt);
+                             ++idx;
+                             return;
+                           }
                          }
+                         ThrowExpectingValueException(commandLineOption);
                        },
-                       [this, &idx, argv](CommandLineOptionalInt OptValueType::*arg) {
-                         if (idx + 1U < argv.size() && IsOptionValue(argv[idx + 1])) {
-                           const char* beg = argv[idx + 1];
-                           const char* end = beg + strlen(beg);
-                           this->*arg = FromString<int>(std::string_view(beg, end));
-                           ++idx;
-                         } else {
-                           this->*arg = CommandLineOptionalInt(CommandLineOptionalInt::State::kOptionPresent);
+
+                       // CommandLineOptionalInt value matcher
+                       [this, &data, &idx, argv](CommandLineOptionalInt OptValueType::*arg) {
+                         data.*arg = CommandLineOptionalInt(CommandLineOptionalInt::State::kOptionPresent);
+                         if (idx + 1U < argv.size()) {
+                           std::string_view nextOpt(argv[idx + 1]);
+                           if (IsOptionInt(nextOpt)) {
+                             data.*arg = FromString<int>(nextOpt);
+                             ++idx;
+                           }
                          }
                        },
-                       [this, &idx, argv, &commandLineOption](std::string_view OptValueType::*arg) {
-                         if (idx + 1U < argv.size() && IsOptionValue(argv[idx + 1])) {
-                           this->*arg = argv[idx + 1];
+
+                       // std::string_view value matcher
+                       [this, &data, &idx, argv, &commandLineOption](std::string_view OptValueType::*arg) {
+                         if (idx + 1U < argv.size()) {
+                           data.*arg = std::string_view(argv[idx + 1]);
                            ++idx;
                          } else {
                            ThrowExpectingValueException(commandLineOption);
                          }
                        },
-                       [this, &idx, argv](std::optional<std::string_view> OptValueType::*arg) {
-                         if (idx + 1U < argv.size() && IsOptionValue(argv[idx + 1])) {
-                           this->*arg = argv[idx + 1];
+
+                       // optional std::string_view value matcher
+                       [this, &data, &idx, argv](std::optional<std::string_view> OptValueType::*arg) {
+                         if (idx + 1U < argv.size() && this->isOptionValue(argv[idx + 1])) {
+                           data.*arg = std::string_view(argv[idx + 1]);
                            ++idx;
                          } else {
-                           this->*arg = std::string_view();
+                           data.*arg = std::string_view();
                          }
                        },
-                       [this, &idx, argv, &commandLineOption](Duration OptValueType::*arg) {
-                         if (idx + 1U < argv.size() && IsOptionValue(argv[idx + 1])) {
-                           this->*arg = ParseDuration(argv[idx + 1]);
+
+                       // duration value matcher
+                       [this, &data, &idx, argv, &commandLineOption](Duration OptValueType::*arg) {
+                         if (idx + 1U < argv.size()) {
+                           data.*arg = ParseDuration(argv[idx + 1]);
                            ++idx;
                          } else {
                            ThrowExpectingValueException(commandLineOption);
@@ -203,7 +231,9 @@ class CommandLineOptionsParser : private OptValueType {
                    prop);
       }
     };
-  };
+  }
+
+  vector<CommandLineOptionWithValue> _opts;
 };
 
 }  // namespace cct
diff --git a/src/engine/src/coincentercommands.cpp b/src/engine/src/coincentercommands.cpp
index abca8dde..7f8faa27 100644
--- a/src/engine/src/coincentercommands.cpp
+++ b/src/engine/src/coincentercommands.cpp
@@ -1,5 +1,6 @@
 #include "coincentercommands.hpp"
 
+#include <algorithm>
 #include <chrono>
 #include <filesystem>
 #include <iostream>
@@ -9,23 +10,45 @@
 #include "coincentercommandtype.hpp"
 #include "coincenteroptions.hpp"
 #include "commandlineoptionsparser.hpp"
+#include "commandlineoptionsparseriterator.hpp"
 #include "stringoptionparser.hpp"
 #include "tradedefinitions.hpp"
 
 namespace cct {
 
-CoincenterCmdLineOptions CoincenterCommands::ParseOptions(int argc, const char *argv[]) {
+vector<CoincenterCmdLineOptions> CoincenterCommands::ParseOptions(int argc, const char *argv[]) {
   using OptValueType = CoincenterCmdLineOptions;
 
   auto parser = CommandLineOptionsParser<OptValueType>(CoincenterAllowedOptions<OptValueType>::value);
-  CoincenterCmdLineOptions parsedOptions = parser.parse(argc, argv);
 
   auto programName = std::filesystem::path(argv[0]).filename().string();
-  if (parsedOptions.help) {
-    parser.displayHelp(programName, std::cout);
-  } else if (parsedOptions.version) {
-    CoincenterCmdLineOptions::PrintVersion(programName);
+
+  vector<CoincenterCmdLineOptions> parsedOptions;
+
+  std::span<const char *> allArguments(argv, argc);
+  allArguments = allArguments.last(allArguments.size() - 1U);  // skip first argument which is program name
+
+  CommandLineOptionsParserIterator parserIt(parser, allArguments);
+
+  // Support for command line multiple commands. Only full name flags are supported for multi command line commands.
+  // Note: maybe it better to just decommission short hand flags.
+  while (parserIt.hasNext()) {
+    std::span<const char *> groupedArguments = parserIt.next();
+
+    CoincenterCmdLineOptions groupParsedOptions = parser.parse(groupedArguments);
+    if (groupedArguments.empty()) {
+      groupParsedOptions.help = true;
+    }
+    if (groupParsedOptions.help) {
+      parser.displayHelp(programName, std::cout);
+    } else if (groupParsedOptions.version) {
+      CoincenterCmdLineOptions::PrintVersion(programName);
+    } else {
+      // Only store commands if they are not 'help' nor 'version'
+      parsedOptions.push_back(std::move(groupParsedOptions));
+    }
   }
+
   return parsedOptions;
 }
 
@@ -103,15 +126,13 @@ WithdrawOptions ComputeWithdrawOptions(const CoincenterCmdLineOptions &cmdLineOp
 
 }  // namespace
 
-CoincenterCommands::CoincenterCommands(const CoincenterCmdLineOptions &cmdLineOptions) {
-  setFromOptions(cmdLineOptions);
-}
-
-bool CoincenterCommands::setFromOptions(const CoincenterCmdLineOptions &cmdLineOptions) {
-  if (cmdLineOptions.help || cmdLineOptions.version) {
-    return false;
+CoincenterCommands::CoincenterCommands(std::span<const CoincenterCmdLineOptions> cmdLineOptionsSpan) {
+  for (const CoincenterCmdLineOptions &cmdLineOptions : cmdLineOptionsSpan) {
+    addOption(cmdLineOptions);
   }
+}
 
+bool CoincenterCommands::addOption(const CoincenterCmdLineOptions &cmdLineOptions) {
   if (cmdLineOptions.repeats.isPresent()) {
     if (cmdLineOptions.repeats.isSet()) {
       _repeats = *cmdLineOptions.repeats;
diff --git a/src/engine/src/commandlineoptionsparseriterator.hpp b/src/engine/src/commandlineoptionsparseriterator.hpp
new file mode 100644
index 00000000..0613fcad
--- /dev/null
+++ b/src/engine/src/commandlineoptionsparseriterator.hpp
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include "commandlineoptionsparser.hpp"
+
+namespace cct {
+
+template <class OptValueType>
+class CommandLineOptionsParserIterator {
+ public:
+  CommandLineOptionsParserIterator(const CommandLineOptionsParser<OptValueType>& parser,
+                                   std::span<const char*> allArguments)
+      : _parser(parser),
+        _allArguments(allArguments),
+        _begIt(_allArguments.begin()),
+        _endIt(getNextGroupedEndIt(_begIt)) {}
+
+  [[nodiscard]] bool hasNext() const { return !_hasReturnedAtLeastOneSpan || _begIt != _endIt; }
+
+  /**
+   * @brief Get next grouped arguments that should be treated together.
+   *        hasNext needs to return true prior to the call to this method
+   */
+  std::span<const char*> next() {
+    std::span<const char*> ret(_begIt, _endIt);
+    _begIt = _endIt;
+    _endIt = getNextGroupedEndIt(_endIt);
+    _hasReturnedAtLeastOneSpan = true;
+    return ret;
+  }
+
+ private:
+  using ConstIt = std::span<const char*>::iterator;
+
+  [[nodiscard]] ConstIt getNextGroupedEndIt(ConstIt searchFromIt) const {
+    if (searchFromIt == _allArguments.end()) {
+      return _allArguments.end();
+    }
+    while (++searchFromIt != _allArguments.end()) {
+      std::string_view optStr(*searchFromIt);
+      for (const auto& [cmdLineOption, _] : _parser._opts) {
+        std::string_view cmdLineOptionFullName = cmdLineOption.fullName();
+        if (cmdLineOptionFullName[0] != '-' && cmdLineOptionFullName == optStr) {
+          return searchFromIt;
+        }
+      }
+    }
+
+    return searchFromIt;
+  }
+
+  const CommandLineOptionsParser<OptValueType>& _parser;
+  std::span<const char*> _allArguments;
+  ConstIt _begIt;
+  ConstIt _endIt;
+  bool _hasReturnedAtLeastOneSpan = false;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/engine/test/commandlineoptionsparser_test.cpp b/src/engine/test/commandlineoptionsparser_test.cpp
index 984992a1..1d186695 100644
--- a/src/engine/test/commandlineoptionsparser_test.cpp
+++ b/src/engine/test/commandlineoptionsparser_test.cpp
@@ -41,102 +41,94 @@ struct MainOptions {
 
 class CommandLineOptionsParserTest : public ::testing::Test {
  public:
-  CommandLineOptionsParserTest() : _parser(MainOptions<Opts>::value) {}
-
   Opts createOptions(std::initializer_list<const char *> init) {
     vector<const char *> opts(init.begin(), init.end());
     return _parser.parse(opts);
   }
 
  protected:
-  void SetUp() override {}
-  void TearDown() override {}
-
-  ParserType _parser;
+  ParserType _parser{MainOptions<Opts>::value};
 };
 
 TEST_F(CommandLineOptionsParserTest, Basic) {
-  Opts options = createOptions({"coincenter", "--opt1", "toto", "--help"});
+  Opts options = createOptions({"--opt1", "toto", "--help"});
   EXPECT_EQ(options.stringOpt, "toto");
   EXPECT_TRUE(options.boolOpt);
 
-  EXPECT_THROW(createOptions({"coincenter", "--opt1", "toto", "--opt3", "--opt2"}), invalid_argument);
-  EXPECT_THROW(createOptions({"coincenter", "--opt1", "toto", "--opts3", "--opt2", "3"}), invalid_argument);
+  EXPECT_THROW(createOptions({"--opt1", "toto", "--opt3", "--opt2"}), invalid_argument);
+  EXPECT_THROW(createOptions({"--opt1", "toto", "--opts3", "--opt2", "3"}), invalid_argument);
 }
 
 TEST_F(CommandLineOptionsParserTest, StringView1) {
-  EXPECT_EQ(createOptions({"coincenter", "--optSV1", "Hey Listen!"}).sv, std::string_view("Hey Listen!"));
+  EXPECT_EQ(createOptions({"--optSV1", "Hey Listen!"}).sv, std::string_view("Hey Listen!"));
 }
 
 TEST_F(CommandLineOptionsParserTest, StringView2) {
-  EXPECT_EQ(createOptions({"coincenter", "--optSV1", ""}).sv, std::string_view(""));
+  EXPECT_EQ(createOptions({"--optSV1", ""}).sv, std::string_view(""));
 }
 
 TEST_F(CommandLineOptionsParserTest, OptStringViewEmpty) {
-  EXPECT_EQ(createOptions({"coincenter", "--optSV2", "--help"}).optSV, std::string_view(""));
+  EXPECT_EQ(createOptions({"--optSV2", "--help"}).optSV, std::string_view(""));
 }
 
 TEST_F(CommandLineOptionsParserTest, OptStringViewNotEmpty) {
-  EXPECT_EQ(*createOptions({"coincenter", "--optSV2", "I need to save the world"}).optSV,
+  EXPECT_EQ(*createOptions({"--optSV2", "I need to save the world"}).optSV,
             std::string_view("I need to save the world"));
 }
 
 TEST_F(CommandLineOptionsParserTest, AlternativeOptionName) {
-  EXPECT_TRUE(createOptions({"coincenter", "-h"}).boolOpt);
-  EXPECT_THROW(createOptions({"coincenter", "-j"}), invalid_argument);
+  EXPECT_TRUE(createOptions({"-h"}).boolOpt);
+  EXPECT_THROW(createOptions({"-j"}), invalid_argument);
 }
 
 TEST_F(CommandLineOptionsParserTest, String) {
-  EXPECT_EQ(createOptions({"coincenter", "--opt1", "2000 EUR, kraken"}).stringOpt, "2000 EUR, kraken");
+  EXPECT_EQ(createOptions({"--opt1", "2000 EUR, kraken"}).stringOpt, "2000 EUR, kraken");
 }
 
 TEST_F(CommandLineOptionsParserTest, OptStringNotEmpty) {
-  EXPECT_EQ(*createOptions({"coincenter", "--opt4", "2000 EUR, kraken"}).optStr, "2000 EUR, kraken");
+  EXPECT_EQ(*createOptions({"--opt4", "2000 EUR, kraken"}).optStr, "2000 EUR, kraken");
 }
 
 TEST_F(CommandLineOptionsParserTest, OptStringEmpty1) {
-  EXPECT_EQ(*createOptions({"coincenter", "--opt4", "--opt1", "Opt1 value"}).optStr, std::string_view());
+  EXPECT_EQ(*createOptions({"--opt4", "--opt1", "Opt1 value"}).optStr, std::string_view());
 }
 
 TEST_F(CommandLineOptionsParserTest, OptStringEmpty2) {
-  EXPECT_EQ(*createOptions({"coincenter", "--opt4"}).optStr, std::string_view());
+  EXPECT_EQ(*createOptions({"--opt4"}).optStr, std::string_view());
 }
 
-TEST_F(CommandLineOptionsParserTest, OptStringEmpty3) {
-  EXPECT_EQ(createOptions({"coincenter", "--help"}).optStr, std::nullopt);
-}
+TEST_F(CommandLineOptionsParserTest, OptStringEmpty3) { EXPECT_EQ(createOptions({"--help"}).optStr, std::nullopt); }
 
 TEST_F(CommandLineOptionsParserTest, OptIntNotEmpty) {
-  CommandLineOptionalInt optInt = createOptions({"coincenter", "--optInt", "-42", "--opt4", "2000 EUR, kraken"}).optInt;
-  EXPECT_EQ(*optInt, -42);
+  CommandLineOptionalInt optInt = createOptions({"--optInt", "-42", "--opt4", "2000 EUR, kraken"}).optInt;
   EXPECT_TRUE(optInt.isPresent());
   EXPECT_TRUE(optInt.isSet());
+  EXPECT_EQ(*optInt, -42);
 }
 
 TEST_F(CommandLineOptionsParserTest, OptIntPresent) {
-  CommandLineOptionalInt optInt = createOptions({"coincenter", "--optInt", "--opt1", "Opt1 value"}).optInt;
+  CommandLineOptionalInt optInt = createOptions({"--optInt", "--opt1", "Opt1 value"}).optInt;
   EXPECT_TRUE(optInt.isPresent());
   EXPECT_FALSE(optInt.isSet());
 }
 
 TEST_F(CommandLineOptionsParserTest, OptIntPresent2) {
-  CommandLineOptionalInt optInt = createOptions({"coincenter", "--opt1", "Opt1 value", "--optInt"}).optInt;
+  CommandLineOptionalInt optInt = createOptions({"--opt1", "Opt1 value", "--optInt"}).optInt;
   EXPECT_TRUE(optInt.isPresent());
   EXPECT_FALSE(optInt.isSet());
 }
 
 TEST_F(CommandLineOptionsParserTest, OptIntUnset) {
-  CommandLineOptionalInt optInt = createOptions({"coincenter", "--opt1", "Opt1 value"}).optInt;
+  CommandLineOptionalInt optInt = createOptions({"--opt1", "Opt1 value"}).optInt;
   EXPECT_FALSE(optInt.isPresent());
 }
 
 TEST_F(CommandLineOptionsParserTest, DurationOptionMinutesSpace) {
-  EXPECT_EQ(createOptions({"coincenter", "--opt5", "1h45 min"}).timeOpt,
-            std::chrono::hours(1) + std::chrono::minutes(45));
+  EXPECT_EQ(createOptions({"--opt5", "1h45 min"}).timeOpt, std::chrono::hours(1) + std::chrono::minutes(45));
 }
 
 TEST_F(CommandLineOptionsParserTest, DurationOptionThrowInvalidTimeUnit1) {
-  EXPECT_THROW(createOptions({"coincenter", "--opt5", "13z"}), invalid_argument);
+  EXPECT_THROW(createOptions({"--opt5", "13z"}), invalid_argument);
 }
 
 struct OptsExt : public Opts {
@@ -155,7 +147,7 @@ static constexpr ExtCommandLineOptionWithValue kAdditionalOpts[] = {
 
 class CommandLineOptionsParserExtTest : public ::testing::Test {
  public:
-  CommandLineOptionsParserExtTest() : _parser(MainOptions<OptsExt>::value) { _parser.append(kAdditionalOpts); }
+  CommandLineOptionsParserExtTest() { _parser.append(kAdditionalOpts); }
 
   OptsExt createOptions(std::initializer_list<const char *> init) {
     vector<const char *> opts(init.begin(), init.end());
@@ -163,21 +155,19 @@ class CommandLineOptionsParserExtTest : public ::testing::Test {
   }
 
  protected:
-  void SetUp() override {}
-  void TearDown() override {}
-
-  ExtParserType _parser;
+  ExtParserType _parser{MainOptions<OptsExt>::value};
 };
 
 TEST_F(CommandLineOptionsParserExtTest, AppendOtherOptions) {
   static_assert(
       StaticCommandLineOptionsCheck(std::to_array(MainOptions<OptsExt>::value), std::to_array(kAdditionalOpts)),
       "It should detect no duplicated option names");
-  EXPECT_EQ(createOptions({"coincenter", "--optSV1", "Hey Listen!"}).sv, std::string_view("Hey Listen!"));
-  EXPECT_EQ(createOptions({"coincenter", "--optExt", "I am your father"}).sv2, std::string_view("I am your father"));
+  EXPECT_EQ(createOptions({"--optSV1", "Hey Listen!"}).sv, std::string_view("Hey Listen!"));
+  EXPECT_EQ(createOptions({"--optExt", "I am your father"}).sv2, std::string_view("I am your father"));
+  EXPECT_NE(createOptions({"--optExt", "I am your father"}).sv, std::string_view("Hey Listen!"));
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnShortName) {
+TEST(CommandLineOptionsParserDuplicatesTest, StaticDuplicateCheckOnShortName) {
   constexpr CommandLineOptionWithValue options[] = {
       {{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
       {{{"General", 1}, "--opt2", "", "Opt2 descr"}, &Opts::intOpt},
@@ -189,7 +179,7 @@ TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnShortName) {
                 "It should detect duplicated options by short name o");
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnLongName) {
+TEST(CommandLineOptionsParserDuplicatesTest, StaticDuplicateCheckOnLongName) {
   constexpr CommandLineOptionWithValue options[] = {
       {{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
       {{{"General", 1}, "--opt2", "", "Opt2 descr"}, &Opts::intOpt},
@@ -201,7 +191,7 @@ TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnLongName) {
                 "It should detect duplicated options by long name --opt2");
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnLongNameCombined) {
+TEST(CommandLineOptionsParserDuplicatesTest, StaticDuplicateCheckOnLongNameCombined) {
   constexpr CommandLineOptionWithValue options1[] = {
       {{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
       {{{"Other", 2}, "--opt2", "", "Opt5 time unit"}, &Opts::timeOpt},
@@ -214,7 +204,7 @@ TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOnLongNameCombi
                 "It should detect duplicated options by long name --help");
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOKCombined) {
+TEST(CommandLineOptionsParserDuplicatesTest, StaticDuplicateCheckOKCombined) {
   constexpr CommandLineOptionWithValue options1[] = {
       {{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
       {{{"Other", 2}, "--opt2", "", "Opt5 time unit"}, &Opts::timeOpt},
@@ -226,7 +216,7 @@ TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOKCombined) {
                 "It should detect no duplicated options");
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOK) {
+TEST(CommandLineOptionsParserDuplicatesTest, StaticDuplicateCheckOK) {
   constexpr CommandLineOptionWithValue options[] = {
       {{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
       {{{"General", 1}, "--opt2", "", "Opt2 descr"}, &Opts::intOpt},
@@ -237,7 +227,7 @@ TEST(CommandLineOptionsParserTestDuplicates, StaticDuplicateCheckOK) {
   static_assert(StaticCommandLineOptionsCheck(std::to_array(options)), "It should not detect duplicated options");
 }
 
-TEST(CommandLineOptionsParserTestDuplicates, NoDuplicateCheckAtRuntime) {
+TEST(CommandLineOptionsParserDuplicatesTest, NoDuplicateCheckAtRuntime) {
   EXPECT_NO_THROW(ParserType({{{{"General", 1}, "--opt1", 'o', "<myValue>", "Opt1 descr"}, &Opts::stringOpt},
                               {{{"General", 1}, "--opt2", "", "Opt2 descr"}, &Opts::intOpt},
                               {{{"Other", 2}, "--opt3", "", "Opt3 descr"}, &Opts::int2Opt},
diff --git a/src/main/src/main.cpp b/src/main/src/main.cpp
index 8d9776ff..0c4174fb 100644
--- a/src/main/src/main.cpp
+++ b/src/main/src/main.cpp
@@ -9,13 +9,14 @@
 
 int main(int argc, const char* argv[]) {
   try {
-    auto cmdLineOptions = cct::CoincenterCommands::ParseOptions(argc, argv);
+    auto cmdLineOptionsVector = cct::CoincenterCommands::ParseOptions(argc, argv);
 
-    if (!cmdLineOptions.help && !cmdLineOptions.version) {
-      cct::CoincenterCommands coincenterCommands(cmdLineOptions);
+    if (!cmdLineOptionsVector.empty()) {
+      cct::CoincenterCommands coincenterCommands(cmdLineOptionsVector);
       auto programName = std::filesystem::path(argv[0]).filename().string();
 
-      cct::ProcessCommandsFromCLI(programName, coincenterCommands, cmdLineOptions, cct::settings::RunMode::kProd);
+      cct::ProcessCommandsFromCLI(programName, coincenterCommands, cmdLineOptionsVector.front(),
+                                  cct::settings::RunMode::kProd);
     }
   } catch (const cct::invalid_argument& e) {
     cct::log::critical("Invalid argument: {}", e.what());
diff --git a/src/main/src/processcommandsfromcli.cpp b/src/main/src/processcommandsfromcli.cpp
index 211adce8..f5644c36 100644
--- a/src/main/src/processcommandsfromcli.cpp
+++ b/src/main/src/processcommandsfromcli.cpp
@@ -7,14 +7,14 @@
 namespace cct {
 
 void ProcessCommandsFromCLI(std::string_view programName, const CoincenterCommands &coincenterCommands,
-                            const CoincenterCmdLineOptions &cmdLineOptions, settings::RunMode runMode) {
+                            const CoincenterCmdLineOptions &generalOptions, settings::RunMode runMode) {
   // Should be outside the try / catch as it holds the RAII object managing the Logging (LoggingInfo)
-  CoincenterInfo coincenterInfo = CoincenterInfo_Create(programName, cmdLineOptions, runMode);
+  CoincenterInfo coincenterInfo = CoincenterInfo_Create(programName, generalOptions, runMode);
 
   CurlInitRAII curlInitRAII;  // Should be before any curl query
 
   try {
-    Coincenter coincenter(coincenterInfo, ExchangeSecretsInfo_Create(cmdLineOptions));
+    Coincenter coincenter(coincenterInfo, ExchangeSecretsInfo_Create(generalOptions));
 
     int nbCommandsProcessed = coincenter.process(coincenterCommands);
 
diff --git a/src/main/src/processcommandsfromcli.hpp b/src/main/src/processcommandsfromcli.hpp
index b58992c1..ae572432 100644
--- a/src/main/src/processcommandsfromcli.hpp
+++ b/src/main/src/processcommandsfromcli.hpp
@@ -8,5 +8,5 @@
 
 namespace cct {
 void ProcessCommandsFromCLI(std::string_view programName, const CoincenterCommands &coincenterCommands,
-                            const CoincenterCmdLineOptions &cmdLineOptions, settings::RunMode runMode);
+                            const CoincenterCmdLineOptions &generalOptions, settings::RunMode runMode);
 }
\ No newline at end of file