Merge pull request #19 from tomdeblauwe/feature/journalctl

shakg · web-flow · commit b583de4ada8f · 2026-04-06T07:58:14.000+03:00
Feature/journalctl
diff --git a/README.md b/README.md
@@ -17,12 +17,16 @@ g-systemctl is a terminal user interface (TUI) for managing system services on L
 - Start/stop services with a single keypress
 - Cross-platform support (Linux via systemctl, macOS via launchctl)
 - Keyboard-driven navigation
+- Mouse support (scroll to navigate, click to select)
+- Initial filter via command line argument (`-f` / `--filter`)
+- View service logs via journalctl (requires tmux)
 
 ## Prerequisites
 
 - CMake 3.14+
 - C++17 compatible compiler (GCC 7+, Clang 5+)
 - Linux with systemd or macOS
+- tmux (optional, required for viewing service logs)
 
 ## Installation
 
@@ -63,16 +67,27 @@ sudo g-systemctl
 | `Down` / `j` | Move selection down |
 | `Enter` | Toggle selected service (start/stop) |
 | `r` | Refresh service list |
+| `l` | Open logs for selected service (tmux only) |
 | `?` | Show/hide help |
 | `q` / `Esc` | Quit |
 | Type | Filter services by name |
 | `Backspace` | Delete filter character |
 
+### Mouse Support
+
+| Action | Effect |
+|--------|--------|
+| Scroll up/down | Navigate the service list |
+| Left click | Select a service |
+
 ## Command Line Options
 
 ```bash
-g-systemctl --help     # Show help
-g-systemctl --version  # Show version
+g-systemctl --help              # Show help
+g-systemctl --version           # Show version
+g-systemctl --system            # Show system services instead of user services
+g-systemctl -f <text>           # Start with an initial filter
+g-systemctl --filter <text>     # Start with an initial filter
 ```
 
 ## Contributing
diff --git a/include/g-systemctl/core/logging_manager.hpp b/include/g-systemctl/core/logging_manager.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <utility>
+
+namespace gsystemctl {
+
+class CommandExecutor; // forward
+
+class LoggingManager {
+public:
+    virtual ~LoggingManager() = default;
+
+    /// Open a log viewer for the given unit.  When running inside tmux this will
+    /// split the current pane and invoke "journalctl -u <unit> -f".  Returns a
+    /// pair of (success,message) where the message contains human readable error
+    /// information in case of failure.
+    virtual std::pair<bool, std::string> open_logs(const std::string& unit) = 0;
+
+    static std::unique_ptr<LoggingManager> create(
+        std::shared_ptr<CommandExecutor> executor);
+};
+
+} // namespace gsystemctl
diff --git a/include/g-systemctl/platform/linux_logging_manager.hpp b/include/g-systemctl/platform/linux_logging_manager.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "g-systemctl/core/logging_manager.hpp"
+#include <memory>
+
+namespace gsystemctl {
+
+class LinuxLoggingManager : public LoggingManager {
+public:
+    explicit LinuxLoggingManager(std::shared_ptr<CommandExecutor> executor);
+
+    std::pair<bool, std::string> open_logs(const std::string& unit) override;
+
+private:
+    std::shared_ptr<CommandExecutor> executor_;
+};
+
+} // namespace gsystemctl
diff --git a/include/g-systemctl/platform/macos_logging_manager.hpp b/include/g-systemctl/platform/macos_logging_manager.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "g-systemctl/core/logging_manager.hpp"
+#include <memory>
+
+namespace gsystemctl {
+
+class MacOSLoggingManager : public LoggingManager {
+public:
+    explicit MacOSLoggingManager(std::shared_ptr<CommandExecutor> executor);
+
+    std::pair<bool, std::string> open_logs(const std::string& unit) override;
+
+private:
+    std::shared_ptr<CommandExecutor> executor_;
+};
+
+} // namespace gsystemctl
diff --git a/include/g-systemctl/ui/app.hpp b/include/g-systemctl/ui/app.hpp
@@ -1,40 +1,49 @@
 #pragma once
 
 #include "g-systemctl/core/service_manager.hpp"
+#include "g-systemctl/core/logging_manager.hpp"
 #include "g-systemctl/core/service.hpp"
 #include <ftxui/component/component.hpp>
 #include <ftxui/component/screen_interactive.hpp>
+#include <ftxui/screen/box.hpp>
 #include <string>
 #include <vector>
 
-namespace gsystemctl::ui {
+namespace gsystemctl::ui
+{
 
-class App {
-public:
-    App(bool system_mode = false);
-    int run();
+    class App
+    {
+    public:
+        App(bool system_mode = false, const std::string &initial_filter = "");
+        int run();
 
-private:
-    ftxui::ScreenInteractive screen_;
-    std::shared_ptr<ServiceManager> service_manager_;
-    bool system_mode_;
+    private:
+        ftxui::ScreenInteractive screen_;
+        std::shared_ptr<ServiceManager> service_manager_;
+        std::unique_ptr<LoggingManager> logging_manager_;
+        bool system_mode_;
 
-    std::vector<ServiceUnit> services_;
-    std::vector<ServiceUnit> filtered_services_;
-    std::string filter_text_;
-    int selected_index_ = 0;
-    std::string status_message_;
-    std::string error_message_;
-    bool show_help_ = false;
+        std::vector<ServiceUnit> services_;
+        std::vector<ServiceUnit> filtered_services_;
+        std::string filter_text_;
+        int selected_index_ = 0;
+        std::string status_message_;
+        std::string error_message_;
+        bool show_help_ = false;
+        std::vector<ftxui::Box> item_boxes_;
+        std::vector<ftxui::Box> toggle_button_boxes_;
+        std::vector<ftxui::Box> log_button_boxes_;
 
-    void refresh_services();
-    void apply_filter();
-    void toggle_selected_service();
-    ftxui::Component create_main_component();
-    ftxui::Element render();
-    ftxui::Element render_service_list();
-    ftxui::Element render_status_bar();
-    ftxui::Element render_help();
-};
+        void refresh_services();
+        void apply_filter();
+        void toggle_selected_service();
+        void open_logs_for_selected_service();
+        ftxui::Component create_main_component();
+        ftxui::Element render();
+        ftxui::Element render_service_list();
+        ftxui::Element render_status_bar();
+        ftxui::Element render_help();
+    };
 
 } // namespace gsystemctl::ui
diff --git a/include/g-systemctl/ui/styles.hpp b/include/g-systemctl/ui/styles.hpp
@@ -1,19 +1,23 @@
 #pragma once
 
 #include <ftxui/dom/elements.hpp>
+#include <ftxui/screen/box.hpp>
 
-namespace gsystemctl::ui {
+namespace gsystemctl::ui
+{
 
-struct Colors {
-    static ftxui::Color running_fg();
-    static ftxui::Color running_bg();
-    static ftxui::Color stopped_fg();
-    static ftxui::Color stopped_bg();
-    static ftxui::Color selected_bg();
-    static ftxui::Color error_fg();
-};
+    struct Colors
+    {
+        static ftxui::Color running_fg();
+        static ftxui::Color running_bg();
+        static ftxui::Color stopped_fg();
+        static ftxui::Color stopped_bg();
+        static ftxui::Color selected_bg();
+        static ftxui::Color error_fg();
+    };
 
-ftxui::Element service_card(const std::string& name, const std::string& status,
-                            const std::string& description, bool is_running, bool selected);
+    ftxui::Element service_card(const std::string &name, const std::string &status,
+                                const std::string &description, bool is_running, bool selected,
+                                ftxui::Box &toggle_box, ftxui::Box &log_box);
 
 } // namespace gsystemctl::ui
diff --git a/src/core/logging_manager.cpp b/src/core/logging_manager.cpp
@@ -0,0 +1,23 @@
+#include "g-systemctl/core/logging_manager.hpp"
+#include "g-systemctl/platform/platform.hpp"
+#include "g-systemctl/platform/linux_logging_manager.hpp"
+#include "g-systemctl/platform/macos_logging_manager.hpp"
+#include <stdexcept>
+
+namespace gsystemctl {
+
+std::unique_ptr<LoggingManager> LoggingManager::create(
+    std::shared_ptr<CommandExecutor> executor) {
+    Platform platform = detect_platform();
+
+    switch (platform) {
+        case Platform::Linux:
+            return std::make_unique<LinuxLoggingManager>(executor);
+        case Platform::MacOS:
+            return std::make_unique<MacOSLoggingManager>(executor);
+        default:
+            throw std::runtime_error("Unsupported platform");
+    }
+}
+
+} // namespace gsystemctl
diff --git a/src/main.cpp b/src/main.cpp
@@ -3,42 +3,58 @@
 #include <iostream>
 #include <cstring>
 
-void print_help() {
+void print_help()
+{
     std::cout << "g-systemctl - Terminal UI for system service management\n\n";
     std::cout << "Usage: g-systemctl [options]\n\n";
     std::cout << "Options:\n";
-    std::cout << "  -h, --help     Show this help message\n";
-    std::cout << "  -v, --version  Show version information\n";
-    std::cout << "  --system       Show system services instead of user services\n\n";
+    std::cout << "  -h, --help              Show this help message\n";
+    std::cout << "  -v, --version           Show version information\n";
+    std::cout << "  --system                Show system services instead of user services\n";
+    std::cout << "  -f, --filter <text>     Set the initial filter text\n\n";
     std::cout << "Note: Run with sudo for full functionality (start/stop services)\n";
 }
 
-void print_version() {
+void print_version()
+{
     std::cout << "g-systemctl version 1.0.0\n";
     std::cout << "Platform: " << gsystemctl::platform_name(gsystemctl::detect_platform()) << "\n";
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[])
+{
     bool system_mode = false;
+    std::string initial_filter;
 
-    for (int i = 1; i < argc; ++i) {
-        if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "--help") == 0) {
+    for (int i = 1; i < argc; ++i)
+    {
+        if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "--help") == 0)
+        {
             print_help();
             return 0;
         }
-        if (std::strcmp(argv[i], "-v") == 0 || std::strcmp(argv[i], "--version") == 0) {
+        if (std::strcmp(argv[i], "-v") == 0 || std::strcmp(argv[i], "--version") == 0)
+        {
             print_version();
             return 0;
         }
-        if (std::strcmp(argv[i], "--system") == 0) {
+        if (std::strcmp(argv[i], "--system") == 0)
+        {
             system_mode = true;
         }
+        if ((std::strcmp(argv[i], "-f") == 0 || std::strcmp(argv[i], "--filter") == 0) && i + 1 < argc)
+        {
+            initial_filter = argv[++i];
+        }
     }
 
-    try {
-        gsystemctl::ui::App app(system_mode);
+    try
+    {
+        gsystemctl::ui::App app(system_mode, initial_filter);
         return app.run();
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception &e)
+    {
         std::cerr << "Error: " << e.what() << "\n";
         return 1;
     }
diff --git a/src/platform/linux_logging_manager.cpp b/src/platform/linux_logging_manager.cpp
@@ -0,0 +1,40 @@
+#include "g-systemctl/platform/linux_logging_manager.hpp"
+#include "g-systemctl/core/command_executor.hpp"
+#include <cstdlib>
+
+namespace gsystemctl {
+
+LinuxLoggingManager::LinuxLoggingManager(std::shared_ptr<CommandExecutor> executor)
+    : executor_(std::move(executor)) {}
+
+std::pair<bool, std::string> LinuxLoggingManager::open_logs(
+    const std::string& unit) {
+    // Ensure we're inside tmux before trying to split the pane.
+    const char* tmux_env = std::getenv("TMUX");
+    if (!tmux_env) {
+        return {false, "Not running inside a tmux session"};
+    }
+
+    // Build the journalctl command. Quote the unit name to avoid shell issues.
+    std::string command = "tmux split-window -v 'journalctl -u " + unit + " -f'";
+    if (!executor_) {
+        // If we don't have an executor, just run the command directly via system().
+        int rc = std::system(command.c_str());
+        if (rc != 0) {
+            return {false, "failed to execute tmux command"};
+        }
+        return {true, ""};
+    }
+
+    auto result = executor_->execute(command);
+    if (result.exit_code != 0) {
+        std::string msg = "tmux command failed";
+        if (!result.stderr_output.empty()) {
+            msg = result.stderr_output;
+        }
+        return {false, msg};
+    }
+    return {true, ""};
+}
+
+} // namespace gsystemctl
diff --git a/src/platform/macos_logging_manager.cpp b/src/platform/macos_logging_manager.cpp
@@ -0,0 +1,13 @@
+#include "g-systemctl/platform/macos_logging_manager.hpp"
+
+namespace gsystemctl {
+
+MacOSLoggingManager::MacOSLoggingManager(std::shared_ptr<CommandExecutor> executor)
+    : executor_(std::move(executor)) {}
+
+std::pair<bool, std::string> MacOSLoggingManager::open_logs(
+    const std::string& /*unit*/) {
+    return {false, "Logging manager is not supported on macOS"};
+}
+
+} // namespace gsystemctl
diff --git a/src/ui/app.cpp b/src/ui/app.cpp
diff --git a/src/ui/styles.cpp b/src/ui/styles.cpp
diff --git a/tests/core/logging_manager_test.cpp b/tests/core/logging_manager_test.cpp
