util: extract preferred_shell helper used by cmd and terminal

Both extensions had their own copy of the same shell-detection loop
checking /bin/{zsh,bash,sh,ash}. Moved into util/shell.hpp as
preferred_shell()/preferred_shell_name(), cached once per process.
ensure_home_env() lives in the same header so other extensions can
also rely on $HOME being populated before forking a child.

Author: alvarolb

src/thinger/iotmp/extensions/cmd/cmd.cpp

@@ -1,47 +1,15 @@
 #include "cmd.hpp"
+#include "../../util/shell.hpp"
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/asio/readable_pipe.hpp>
 #include <boost/asio/writable_pipe.hpp>
 #include <boost/process/v2/process.hpp>
 #include <boost/process/v2/stdio.hpp>
-#include <cstdlib>
-#include <filesystem>
-#include <pwd.h>
-#include <unistd.h>
 
 namespace thinger::iotmp{
 
-    namespace {
-        const std::string& preferred_shell() {
-            static const std::string shell = [] {
-                // Preference order matches the interactive terminal extension.
-                for (const char* name : {"zsh", "bash", "sh", "ash"}) {
-                    std::string path = std::string("/bin/") + name;
-                    if (std::filesystem::exists(path)) return path;
-                }
-                return std::string("/bin/sh");
-            }();
-            return shell;
-        }
-
-        // Child processes of the agent inherit its environment. systemd units
-        // without User= or in older systemd do not populate HOME, which
-        // surprises scripts that rely on it (cd ~, tilde expansion, etc.).
-        // Resolve HOME from the password database on first use.
-        void ensure_home_env() {
-            static const bool done = [] {
-                if (std::getenv("HOME")) return true;
-                if (passwd* pw = getpwuid(getuid()); pw && pw->pw_dir && *pw->pw_dir) {
-                    setenv("HOME", pw->pw_dir, 0);
-                }
-                return true;
-            }();
-            (void)done;
-        }
-    }
-
     cmd::cmd(client& client)
     {
         ensure_home_env();

src/thinger/iotmp/extensions/terminal/terminal_session.cpp

@@ -1,8 +1,8 @@
 #include "terminal_session.hpp"
+#include "../../util/shell.hpp"
 
 #include <boost/process.hpp>
 #include <boost/asio.hpp>
-#include <filesystem>
 #include <thinger/util/logger.hpp>
 
 #ifdef __linux__
@@ -18,14 +18,7 @@ terminal_session::terminal_session(client& client, uint16_t stream_id, std::stri
     : stream_session(client, stream_id, std::move(session)),
       descriptor_(client.get_io_context())
 {
-    // Find available terminal
-    std::vector<std::string> terminals{"zsh", "bash", "sh", "ash"};
-    for(auto& terminal : terminals) {
-        if(std::filesystem::exists("/bin/" + terminal)) {
-            terminal_ = terminal;
-            break;
-        }
-    }
+    terminal_ = preferred_shell_name();
 
     // Initialize cols and rows from parameters
     cols_ = get_value(parameters, "cols", 80u);

src/thinger/iotmp/util/shell.hpp

@@ -0,0 +1,62 @@
+#ifndef THINGER_IOTMP_UTIL_SHELL_HPP
+#define THINGER_IOTMP_UTIL_SHELL_HPP
+
+#include <cstdlib>
+#include <filesystem>
+#include <string>
+
+#ifndef _WIN32
+#include <pwd.h>
+#include <unistd.h>
+#endif
+
+namespace thinger::iotmp {
+
+    // Returns the absolute path of the shell the agent should use for both
+    // non-interactive command execution (cmd extension) and interactive
+    // terminal sessions. Preference order: zsh, bash, sh, ash. Resolved once
+    // per process and cached.
+    inline const std::string& preferred_shell() {
+        static const std::string shell = [] {
+            for (const char* name : {"zsh", "bash", "sh", "ash"}) {
+                std::string path = std::string("/bin/") + name;
+                if (std::filesystem::exists(path)) return path;
+            }
+            return std::string("/bin/sh");
+        }();
+        return shell;
+    }
+
+    // Returns the name of the preferred shell without its directory (e.g.,
+    // "bash"). Useful for interactive terminal sessions that execve with a
+    // plain basename.
+    inline const std::string& preferred_shell_name() {
+        static const std::string name = [] {
+            const std::string& full = preferred_shell();
+            auto slash = full.find_last_of('/');
+            return slash == std::string::npos ? full : full.substr(slash + 1);
+        }();
+        return name;
+    }
+
+    // Populates $HOME in the current process environment if it is unset.
+    // Child processes launched by the agent inherit this, so scripts that
+    // rely on HOME (cd ~, tilde expansion) keep working even when the
+    // service was started without User= or on older systemd that does not
+    // populate HOME. Idempotent and safe to call multiple times.
+    inline void ensure_home_env() {
+#ifndef _WIN32
+        static const bool done = [] {
+            if (std::getenv("HOME")) return true;
+            if (passwd* pw = getpwuid(getuid()); pw && pw->pw_dir && *pw->pw_dir) {
+                setenv("HOME", pw->pw_dir, 0);
+            }
+            return true;
+        }();
+        (void)done;
+#endif
+    }
+
+} // namespace thinger::iotmp
+
+#endif // THINGER_IOTMP_UTIL_SHELL_HPP