Hide irrelevant commands in cvd help by default

Only show relevant commands and selector options when no devices are
running. All commands are shown if devices are running, with
device-specific commands displayed first.

Output without a running device:
================================
```
Cuttlefish Virtual Device (CVD) CLI.

usage: cvd <selector/driver options> <command> <args>

Driver Options:
  -help                  Print this message
  -verbosity=<LEVEL>     Adjust Cvd verbosity level. LEVEL is Android log
                         severity. (Required: cvd >= v1.3)

Commands (cvd help <command> for more information):
	cache - Manage the files cached by cvd

	create - Create a Cuttlefish virtual device or environment

	fetch, fetch_cvd - Retrieve build artifacts based on branch and target names

	help - Used to display help information for other commands

	lint - error checks the input virtual device json config file

	load - Loads the given JSON configuration file and launches devices based on the options provided

	login - Acquire credentials

	reset - Used to stop devices, optionally clean up instance files, and shut down the deprecated cvd server process

	version - Prints version of cvd client and cvd server
```

Output with a running device:
=============================
```
Cuttlefish Virtual Device (CVD) CLI.

usage: cvd <selector/driver options> <command> <args>

Selector Options:
  -group_name <name>     Specify the name of the instance group created
                         or selected.
  -instance_name <name>  Selects the device of the given name to perform the
                         commands for.
  -instance_name <names> Takes the names of the devices to create within an
                         instance group. The 'names' is comma-separated.

Device-Specific Commands (cvd help <command> for more information):
	display - Enables hotplug/unplug of displays from running cuttlefish virtual devices

	env - Enumerate + Query APIs for all gRPC services made available by this virtual device instance

	fleet - lists active devices with relevant information

	clear - Clears the instance database, stopping any running instances first.

	bugreport, host_bugreport, cvd_host_bugreport - Run cvd bugreport --help for command description

	stop, stop_cvd - Stop all instances in a group

	powerbtn - Trigger power button event on the device

	powerwash - Reset device to first boot state

	restart - Restart device

	remove, rm - Remove devices and artifacts from the system.

	screen_recording - Record screen contents

	suspend, resume, snapshot_take - Suspend/resume the cuttlefish device, or take snapshot of the device

	start, launch_cvd - Start a Cuttlefish virtual device or environment

	status, cvd_status - Query status of a single instance group.  Use `cvd fleet` for all devices

Driver Options:
  -help                  Print this message
  -verbosity=<LEVEL>     Adjust Cvd verbosity level. LEVEL is Android log
                         severity. (Required: cvd >= v1.3)

Commands (cvd help <command> for more information):
	cache - Manage the files cached by cvd

	create - Create a Cuttlefish virtual device or environment

	fetch, fetch_cvd - Retrieve build artifacts based on branch and target names

	help - Used to display help information for other commands

	lint - error checks the input virtual device json config file

	load - Loads the given JSON configuration file and launches devices based on the options provided

	login - Acquire credentials

	reset - Used to stop devices, optionally clean up instance files, and shut down the deprecated cvd server process

	version - Prints version of cvd client and cvd server
```

Bug: b/504758273
Assisted-by: Gemini:Next

Author: Databean

base/cvd/cuttlefish/host/commands/cvd/cli/commands/bugreport.cpp

@@ -98,6 +98,7 @@ class CvdBugreportCommandHandler : public CvdCommandHandler {
   cvd_common::Args CmdList() const override;
   Result<std::string> SummaryHelp() const override;
   bool ShouldInterceptHelp() const override;
+  bool RequiresRunningDevice() const override;
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override;
 
  private:
@@ -187,6 +188,7 @@ Result<std::string> CvdBugreportCommandHandler::SummaryHelp() const {
 }
 
 bool CvdBugreportCommandHandler::ShouldInterceptHelp() const { return false; }
+bool CvdBugreportCommandHandler::RequiresRunningDevice() const { return true; }
 
 Result<std::string> CvdBugreportCommandHandler::DetailedHelp(
     std::vector<std::string>& arguments) const {

base/cvd/cuttlefish/host/commands/cvd/cli/commands/clear.cpp

@@ -41,6 +41,7 @@ class CvdClearCommandHandler : public CvdCommandHandler {
   cvd_common::Args CmdList() const override { return {kClearCmd}; }
   Result<std::string> SummaryHelp() const override { return kSummaryHelpText; }
   bool ShouldInterceptHelp() const override { return true; }
+  bool RequiresRunningDevice() const override { return true; }
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override;
 
  private:

base/cvd/cuttlefish/host/commands/cvd/cli/commands/command_handler.cpp

@@ -26,4 +26,6 @@ Result<bool> CvdCommandHandler::CanHandle(const CommandRequest& request) const {
   return Contains(CmdList(), request.Subcommand());
 }
 
+bool CvdCommandHandler::RequiresRunningDevice() const { return false; }
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/cli/commands/command_handler.h

@@ -35,6 +35,7 @@ class CvdCommandHandler {
   virtual cvd_common::Args CmdList() const = 0;
   // used for command help text
   virtual Result<std::string> SummaryHelp() const = 0;
+  virtual bool RequiresRunningDevice() const;
   virtual bool ShouldInterceptHelp() const = 0;
   virtual Result<std::string> DetailedHelp(std::vector<std::string>&) const = 0;
 };

base/cvd/cuttlefish/host/commands/cvd/cli/commands/display.cpp

@@ -91,6 +91,8 @@ class CvdDisplayCommandHandler : public CvdCommandHandler {
 
   bool ShouldInterceptHelp() const override { return true; }
 
+  bool RequiresRunningDevice() const override { return true; }
+
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override {
     return kDetailedHelpText;
   }

base/cvd/cuttlefish/host/commands/cvd/cli/commands/env.cpp

@@ -89,6 +89,8 @@ class CvdEnvCommandHandler : public CvdCommandHandler {
 
   bool ShouldInterceptHelp() const override { return true; }
 
+  bool RequiresRunningDevice() const override { return true; }
+
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override {
     return kDetailedHelpText;
   }

base/cvd/cuttlefish/host/commands/cvd/cli/commands/fleet.cpp

@@ -52,6 +52,8 @@ class CvdFleetCommandHandler : public CvdCommandHandler {
 
   bool ShouldInterceptHelp() const override { return true; }
 
+  bool RequiresRunningDevice() const override { return true; }
+
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override {
     return kHelpMessage;
   }

base/cvd/cuttlefish/host/commands/cvd/cli/commands/help.cpp

@@ -24,12 +24,14 @@
 #include <vector>
 
 #include "absl/strings/str_join.h"
+#include "cuttlefish/common/libs/utils/contains.h"
 #include "absl/log/check.h"
 
 #include "cuttlefish/host/commands/cvd/cli/command_request.h"
 #include "cuttlefish/host/commands/cvd/cli/commands/command_handler.h"
 #include "cuttlefish/host/commands/cvd/cli/request_context.h"
 #include "cuttlefish/host/commands/cvd/cli/types.h"
+#include "cuttlefish/host/commands/cvd/instances/instance_manager.h"
 #include "cuttlefish/result/result.h"
 
 namespace cuttlefish {
@@ -38,15 +40,19 @@ namespace {
 constexpr char kHelpIntroText[] = R"(Cuttlefish Virtual Device (CVD) CLI.
 
 usage: cvd <selector/driver options> <command> <args>
+)";
 
+constexpr char kSelectorOptionsText[] = R"(
 Selector Options:
   -group_name <name>     Specify the name of the instance group created
                          or selected.
   -instance_name <name>  Selects the device of the given name to perform the
                          commands for.
   -instance_name <names> Takes the names of the devices to create within an
                          instance group. The 'names' is comma-separated.
+)";
 
+constexpr char kDriverOptionsText[] = R"(
 Driver Options:
   -help                  Print this message
   -verbosity=<LEVEL>     Adjust Cvd verbosity level. LEVEL is Android log
@@ -66,15 +72,20 @@ Example usage:
   cvd help <command> - displays more detailed help for the specific command
 )";
 
-constexpr char kIgnorableHandlerCommand[] = "experimental";
+const std::vector<std::string> kIgnoredCommandLists = {
+    "experimental",
+    "server-kill, kill-server, restart-server",
+};
 
 }  // namespace
 
 class CvdHelpHandler : public CvdCommandHandler {
  public:
   CvdHelpHandler(
-      const std::vector<std::unique_ptr<CvdCommandHandler>>& request_handlers)
-      : request_handlers_(request_handlers) {}
+      const std::vector<std::unique_ptr<CvdCommandHandler>>& request_handlers,
+      InstanceManager& instance_manager)
+      : request_handlers_(request_handlers),
+        instance_manager_(instance_manager) {}
 
   Result<void> Handle(const CommandRequest& request) override {
     CF_EXPECT(CanHandle(request));
@@ -109,20 +120,45 @@ class CvdHelpHandler : public CvdCommandHandler {
 
   Result<std::string> TopLevelHelp() {
     std::stringstream help_message;
-    help_message << kHelpIntroText << std::endl;
+    help_message << kHelpIntroText;
+    bool devices_running = CF_EXPECT(instance_manager_.HasInstanceGroups());
+    if (devices_running) {
+      help_message << kSelectorOptionsText;
+    }
+
+    if (devices_running) {
+      help_message << "\nDevice-Specific Commands (cvd help <command> for more information):\n";
+      for (const auto& handler : request_handlers_) {
+        if (handler->RequiresRunningDevice()) {
+          CF_EXPECT(PrintHandler(help_message, *handler));
+        }
+      }
+    }
+
+    help_message << kDriverOptionsText << std::endl;
+
     for (const auto& handler : request_handlers_) {
-      std::string command_list = absl::StrJoin(handler->CmdList(), ", ");
-      // exclude commands without any command list values as not intended for
-      // use by users or sub-subcommands
-      if (!command_list.empty() && command_list != kIgnorableHandlerCommand) {
-        help_message << "\t" << command_list << " - ";
-        help_message << CF_EXPECT(handler->SummaryHelp()) << std::endl
-                     << std::endl;
+      if (!handler->RequiresRunningDevice()) {
+        CF_EXPECT(PrintHandler(help_message, *handler));
       }
     }
+
     return help_message.str();
   }
 
+  Result<void> PrintHandler(
+      std::stringstream& help_message,
+      const CvdCommandHandler& handler) const {
+    std::string command_list = absl::StrJoin(handler.CmdList(), ", ");
+    if (!command_list.empty() &&
+        !Contains(kIgnoredCommandLists, command_list)) {
+      help_message << "\t" << command_list << " - ";
+      help_message << CF_EXPECT(handler.SummaryHelp()) << std::endl
+                   << std::endl;
+    }
+    return {};
+  }
+
   Result<std::string> SubCommandHelp(std::vector<std::string>& args) {
     CF_EXPECT(
         !args.empty(),
@@ -136,11 +172,14 @@ class CvdHelpHandler : public CvdCommandHandler {
   }
 
   const std::vector<std::unique_ptr<CvdCommandHandler>>& request_handlers_;
+  InstanceManager& instance_manager_;
 };
 
 std::unique_ptr<CvdCommandHandler> NewCvdHelpHandler(
-    const std::vector<std::unique_ptr<CvdCommandHandler>>& server_handlers) {
-  return std::unique_ptr<CvdCommandHandler>(new CvdHelpHandler(server_handlers));
+    const std::vector<std::unique_ptr<CvdCommandHandler>>& server_handlers,
+    InstanceManager& instance_manager) {
+  return std::unique_ptr<CvdCommandHandler>(
+      new CvdHelpHandler(server_handlers, instance_manager));
 }
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/cli/commands/help.h

@@ -22,7 +22,9 @@
 #include "cuttlefish/host/commands/cvd/cli/commands/command_handler.h"
 
 namespace cuttlefish {
+class InstanceManager;
 
 std::unique_ptr<CvdCommandHandler> NewCvdHelpHandler(
-    const std::vector<std::unique_ptr<CvdCommandHandler>>& server_handlers);
+    const std::vector<std::unique_ptr<CvdCommandHandler>>& server_handlers,
+    InstanceManager& instance_manager);
 }

base/cvd/cuttlefish/host/commands/cvd/cli/commands/noop.cpp

@@ -50,6 +50,8 @@ class CvdNoopHandler : public CvdCommandHandler {
 
   bool ShouldInterceptHelp() const override { return true; }
 
+  bool RequiresRunningDevice() const override { return true; }
+
   Result<std::string> DetailedHelp(std::vector<std::string>&) const override {
     return "DEPRECATED: This command is a no-op";
   }