Add CvdMonitor command to monitor device logs.

This command repeatedly clears and prints the last 10 lines of
launcher.log, kernel.log, and logcat in a bordered ASCII box.
It includes unit tests for the display logic.

Assisted-by: Jetski
Bug: b/510094996

Author: Databean

base/cvd/cuttlefish/host/commands/cvd/cli/BUILD.bazel

@@ -91,6 +91,7 @@ cf_cc_library(
         "//cuttlefish/host/commands/cvd/cli/commands:login",
         "//cuttlefish/host/commands/cvd/cli/commands:power_btn",
         "//cuttlefish/host/commands/cvd/cli/commands:powerwash",
+        "//cuttlefish/host/commands/cvd/cli/commands:monitor",
         "//cuttlefish/host/commands/cvd/cli/commands:remove",
         "//cuttlefish/host/commands/cvd/cli/commands:reset",
         "//cuttlefish/host/commands/cvd/cli/commands:restart",

base/cvd/cuttlefish/host/commands/cvd/cli/commands/BUILD.bazel

@@ -1,4 +1,4 @@
-load("//cuttlefish/bazel:rules.bzl", "cf_cc_library")
+load("//cuttlefish/bazel:rules.bzl", "cf_cc_library", "cf_cc_test")
 
 package(
     default_visibility = ["//:android_cuttlefish"],
@@ -259,6 +259,29 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "monitor",
+    srcs = ["monitor.cpp"],
+    hdrs = ["monitor.h"],
+    deps = [
+        "//cuttlefish/common/libs/fs",
+        "//cuttlefish/common/libs/utils:flag_parser",
+        "//cuttlefish/host/commands/cvd/cli:command_request",
+        "//cuttlefish/host/commands/cvd/cli:types",
+        "//cuttlefish/host/commands/cvd/cli:utils",
+        "//cuttlefish/host/commands/cvd/cli/commands:command_handler",
+        "//cuttlefish/host/commands/cvd/cli/selector",
+        "//cuttlefish/host/commands/cvd/instances",
+        "//cuttlefish/host/commands/cvd/instances:instance_manager",
+        "//cuttlefish/result",
+        "//libbase",
+        "@fmt",
+    ],
+)
+
+
+
+
 cf_cc_library(
     name = "screen_recording",
     srcs = ["screen_recording.cpp"],
@@ -453,3 +476,18 @@ cf_cc_library(
         "@jsoncpp",
     ],
 )
+
+cf_cc_test(
+    name = "monitor_test",
+    srcs = ["monitor_test.cpp"],
+    deps = [
+        ":monitor",
+        "//cuttlefish/common/libs/fs",
+        "//cuttlefish/result:result_matchers",
+        "@abseil-cpp//absl/strings",
+    ],
+)
+
+
+
+

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

@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cuttlefish/host/commands/cvd/cli/commands/monitor.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstddef>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "cuttlefish/common/libs/fs/shared_fd.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/selector/selector.h"
+#include "cuttlefish/host/commands/cvd/cli/types.h"
+#include "cuttlefish/host/commands/cvd/cli/utils.h"
+#include "cuttlefish/host/commands/cvd/instances/instance_manager.h"
+#include "cuttlefish/result/result.h"
+
+namespace cuttlefish {
+
+namespace {
+
+Result<std::vector<std::string>> GetLastNLines(SharedFD fd, int n) {
+  off_t file_size = fd->LSeek(0, SEEK_END);
+  CF_EXPECT(file_size != -1, "Failed to seek to end of file");
+
+  std::vector<std::string> lines;
+  std::string current_line = "";
+  off_t offset = file_size;
+  const size_t kChunkSize = 4096;
+
+  while (offset > 0 && lines.size() < static_cast<size_t>(n)) {
+    size_t to_read = std::min(static_cast<off_t>(kChunkSize), offset);
+    offset -= to_read;
+    fd->LSeek(offset, SEEK_SET);
+
+    std::string chunk(to_read, '\0');
+    ssize_t bytes_read = fd->Read(chunk.data(), to_read);
+    CF_EXPECT(bytes_read == static_cast<ssize_t>(to_read), "Read failed");
+
+    for (ssize_t i = to_read - 1; i >= 0; --i) {
+      char c = chunk[i];
+      if (c == '\n') {
+        if (offset + i == file_size - 1) {
+          continue;
+        }
+        std::reverse(current_line.begin(), current_line.end());
+        lines.insert(lines.begin(), current_line);
+        current_line.clear();
+        if (lines.size() >= static_cast<size_t>(n)) {
+          break;
+        }
+      } else {
+        current_line.push_back(c);
+      }
+    }
+  }
+
+  if (lines.size() < static_cast<size_t>(n) && !current_line.empty()) {
+    std::reverse(current_line.begin(), current_line.end());
+    lines.insert(lines.begin(), current_line);
+  }
+
+  return lines;
+}
+
+}  // namespace
+
+LogMonitorDisplay::LogMonitorDisplay(int width)
+    : width_(width), total_lines_drawn_(0) {}
+
+void LogMonitorDisplay::DrawFile(SharedFD fd, const std::string& title) {
+  std::vector<std::string> lines;
+  if (!fd->IsOpen()) {
+    lines.push_back("Failed to read " + title + ": File not open");
+  } else {
+    Result<std::vector<std::string>> lines_result = GetLastNLines(fd, 10);
+    if (!lines_result.ok()) {
+      lines.push_back("Failed to read " + title + ": " +
+                      lines_result.error().Message());
+    } else {
+      lines = *lines_result;
+    }
+  }
+
+  while (lines.size() < 10) {
+    lines.push_back("");
+  }
+
+  DrawBorderedText(lines, title);
+  total_lines_drawn_ += 11;
+}
+
+std::string LogMonitorDisplay::Finalize() {
+  std::string bottom_border = "+";
+  if (width_ > 2) {
+    bottom_border += std::string(width_ - 2, '-');
+    bottom_border += "+";
+  }
+  ss_ << bottom_border << std::endl;
+  total_lines_drawn_++;
+  return ss_.str();
+}
+
+int LogMonitorDisplay::TotalLinesDrawn() const { return total_lines_drawn_; }
+
+void LogMonitorDisplay::DrawBorderedText(const std::vector<std::string>& lines,
+                                         const std::string& title) {
+  // Top border
+  std::string top_border = "+--" + title + " ";
+  if (top_border.length() > static_cast<size_t>(width_)) {
+    top_border = top_border.substr(0, width_);
+  }
+  ss_ << top_border;
+  if (top_border.length() < static_cast<size_t>(width_)) {
+    ss_ << std::string(width_ - top_border.length() - 1, '-');
+    ss_ << "+";
+  }
+  ss_ << std::endl;
+
+  for (const auto& line : lines) {
+    std::string processed_line = line;
+    processed_line.erase(
+        std::remove(processed_line.begin(), processed_line.end(), '\r'),
+        processed_line.end());
+    processed_line.erase(
+        std::remove(processed_line.begin(), processed_line.end(), '\n'),
+        processed_line.end());
+
+    std::string expanded_line = "";
+    for (char c : processed_line) {
+      if (c == '\t') {
+        expanded_line += "    ";
+      } else {
+        expanded_line.push_back(c);
+      }
+    }
+
+    std::string truncated_line = expanded_line;
+    int content_width = width_ - 2;
+    if (content_width < 0) {
+      content_width = 0;
+    }
+
+    if (truncated_line.length() > static_cast<size_t>(content_width)) {
+      truncated_line = truncated_line.substr(0, content_width);
+    }
+
+    std::string middle_line = "|";
+    middle_line += truncated_line;
+    if (middle_line.length() < static_cast<size_t>(width_ - 1)) {
+      middle_line += std::string(width_ - 1 - middle_line.length(), ' ');
+    }
+    if (width_ > 1) {
+      middle_line += "|";
+    }
+    ss_ << middle_line << std::endl;
+  }
+}
+
+namespace {
+
+constexpr char kSummaryHelpText[] = "Monitor a particular device";
+constexpr char kDetailedHelpText[] =
+    R"(monitor: Monitors a particular device.
+
+Flags:
+    None yet.
+)";
+
+constexpr char kMonitorCmd[] = "monitor";
+
+void ClearLastNLines(int n) {
+  if (n > 0) {
+    // Move cursor up N lines and clear to end of screen
+    std::cout << "\033[" << n << "A\033[J" << std::flush;
+  }
+}
+
+class CvdMonitorCommandHandler : public CvdCommandHandler {
+ public:
+  CvdMonitorCommandHandler(InstanceManager& instance_manager)
+      : instance_manager_{instance_manager} {}
+
+  Result<void> Handle(const CommandRequest& request) override {
+    CF_EXPECT(CanHandle(request));
+
+    std::vector<std::string> subcmd_args = request.SubcommandArguments();
+    // Parse flags if needed, none for now.
+
+    CF_EXPECT(isatty(0),
+              "The monitor command requires an interactive terminal.");
+
+    auto [instance, unused] =
+        CF_EXPECT(selector::SelectInstance(instance_manager_, request),
+                  "Unable to select an instance");
+
+    std::string kernel_log = instance.instance_dir() + "/logs/kernel.log";
+    std::string launcher_log = instance.instance_dir() + "/logs/launcher.log";
+    std::string logcat = instance.instance_dir() + "/logs/logcat";
+
+    SharedFD kernel_fd;
+    SharedFD launcher_fd;
+    SharedFD logcat_fd;
+
+    while (true) {
+      if (!kernel_fd->IsOpen()) {
+        kernel_fd = SharedFD::Open(kernel_log, O_RDONLY);
+      }
+      if (!launcher_fd->IsOpen()) {
+        launcher_fd = SharedFD::Open(launcher_log, O_RDONLY);
+      }
+      if (!logcat_fd->IsOpen()) {
+        logcat_fd = SharedFD::Open(logcat, O_RDONLY);
+      }
+
+      Result<TerminalSize> term_size_result = GetTerminalSize();
+      int width = 79;  // Default fallback width (80 - 1)
+      if (term_size_result.ok()) {
+        width = term_size_result->columns - 1;
+      }
+      LogMonitorDisplay display(width);
+
+      display.DrawFile(launcher_fd, "launcher.log");
+      display.DrawFile(kernel_fd, "kernel.log");
+      display.DrawFile(logcat_fd, "logcat");
+
+      std::cout << display.Finalize() << std::flush;
+
+      // Wait a bit before clearing and redrawing
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+      ClearLastNLines(display.TotalLinesDrawn());
+    }
+
+    return {};
+  }
+
+  cvd_common::Args CmdList() const override { return {kMonitorCmd}; }
+
+  Result<std::string> SummaryHelp() const override { return kSummaryHelpText; }
+
+  bool RequiresDeviceExists() const override { return true; }
+
+  Result<std::string> DetailedHelp(
+      const CommandRequest& request) const override {
+    return kDetailedHelpText;
+  }
+
+ private:
+  InstanceManager& instance_manager_;
+};
+
+}  // namespace
+
+std::unique_ptr<CvdCommandHandler> NewCvdMonitorCommandHandler(
+    InstanceManager& instance_manager) {
+  return std::unique_ptr<CvdCommandHandler>(
+      new CvdMonitorCommandHandler(instance_manager));
+}
+
+}  // namespace cuttlefish