summaryrefslogtreecommitdiff
path: root/hyprctl/src
diff options
context:
space:
mode:
authorVaxry <43317083+vaxerski@users.noreply.github.com>2025-12-04 17:59:47 +0000
committerGitHub <noreply@github.com>2025-12-04 17:59:47 +0000
commitd9657a95cb6706860332ff47dad444a96bcc874a (patch)
tree948f071656f942f9681189c7febab371b094e5f5 /hyprctl/src
parent9b1891e4765e2c5b84c8c61725e3973ca9940e05 (diff)
hyprctl: use new hyprpaper ipc format (#12537)
--------- Co-authored-by: Mihai Fufezan <mihai@fufexan.net>
Diffstat (limited to 'hyprctl/src')
-rw-r--r--hyprctl/src/Strings.hpp183
-rw-r--r--hyprctl/src/helpers/Memory.hpp11
-rw-r--r--hyprctl/src/hyprpaper/Hyprpaper.cpp148
-rw-r--r--hyprctl/src/hyprpaper/Hyprpaper.hpp8
-rw-r--r--hyprctl/src/main.cpp539
5 files changed, 889 insertions, 0 deletions
diff --git a/hyprctl/src/Strings.hpp b/hyprctl/src/Strings.hpp
new file mode 100644
index 00000000..549d84bb
--- /dev/null
+++ b/hyprctl/src/Strings.hpp
@@ -0,0 +1,183 @@
+#pragma once
+
+#include <string_view>
+
+const std::string_view USAGE = R"#(usage: hyprctl [flags] <command> [args...|--help]
+
+commands:
+ activewindow → Gets the active window name and its properties
+ activeworkspace → Gets the active workspace and its properties
+ animations → Gets the current config'd info about animations
+ and beziers
+ binds → Lists all registered binds
+ clients → Lists all windows with their properties
+ configerrors → Lists all current config parsing errors
+ cursorpos → Gets the current cursor position in global layout
+ coordinates
+ decorations <window_regex> → Lists all decorations and their info
+ devices → Lists all connected keyboards and mice
+ dismissnotify [amount] → Dismisses all or up to AMOUNT notifications
+ dispatch <dispatcher> [args] → Issue a dispatch to call a keybind
+ dispatcher with arguments
+ getoption <option> → Gets the config option status (values)
+ globalshortcuts → Lists all global shortcuts
+ hyprpaper ... → Issue a hyprpaper request
+ hyprsunset ... → Issue a hyprsunset request
+ instances → Lists all running instances of Hyprland with
+ their info
+ keyword <name> <value> → Issue a keyword to call a config keyword
+ dynamically
+ kill → Issue a kill to get into a kill mode, where you can
+ kill an app by clicking on it. You can exit it
+ with ESCAPE
+ layers → Lists all the surface layers
+ layouts → Lists all layouts available (including plugin'd ones)
+ monitors → Lists active outputs with their properties,
+ 'monitors all' lists active and inactive outputs
+ notify ... → Sends a notification using the built-in Hyprland
+ notification system
+ output ... → Allows you to add and remove fake outputs to your
+ preferred backend
+ plugin ... → Issue a plugin request
+ reload [config-only] → Issue a reload to force reload the config. Pass
+ 'config-only' to disable monitor reload
+ rollinglog → Prints tail of the log. Also supports -f/--follow
+ option
+ setcursor <theme> <size> → Sets the cursor theme and reloads the cursor
+ manager
+ seterror <color> <message...> → Sets the hyprctl error string. Color has
+ the same format as in colors in config. Will reset
+ when Hyprland's config is reloaded
+ setprop ... → Sets a window property
+ getprop ... → Gets a window property
+ splash → Get the current splash
+ switchxkblayout ... → Sets the xkb layout index for a keyboard
+ systeminfo → Get system info
+ version → Prints the hyprland version, meaning flags, commit
+ and branch of build.
+ workspacerules → Lists all workspace rules
+ workspaces → Lists all workspaces with their properties
+
+flags:
+ -j → Output in JSON
+ -r → Refresh state after issuing command (e.g. for
+ updating variables)
+ --batch → Execute a batch of commands, separated by ';'
+ --instance (-i) → use a specific instance. Can be either signature or
+ index in hyprctl instances (0, 1, etc)
+ --quiet (-q) → Disable the output of hyprctl
+
+--help:
+ Can be used to print command's arguments that did not fit into this page
+ (three dots))#";
+
+const std::string_view HYPRPAPER_HELP = R"#(usage: hyprctl [flags] hyprpaper <request>
+
+requests:
+ wallpaper → Issue a wallpaper to call a config wallpaper dynamically.
+ Arguments are [mon],[path],[fit_mode]. Fit mode is optional.
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view HYPRSUNSET_HELP = R"#(usage: hyprctl [flags] hyprsunset <request>
+
+requests:
+ temperature <temp> → Enable blue-light filter
+ identity → Disable blue-light filter
+ gamma <gamma> → Enable gamma filter
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view NOTIFY_HELP = R"#(usage: hyprctl [flags] notify <icon> <time_ms> <color> <message...>
+
+icon:
+ Integer of value:
+ 0 → Warning
+ 1 → Info
+ 2 → Hint
+ 3 → Error
+ 4 → Confused
+ 5 → Ok
+ 6 or -1 → No icon
+
+time_ms:
+ Time to display notification in milliseconds
+
+color:
+ Notification color. Format is the same as for colors in hyprland.conf. Use
+ 0 for default color for icon
+
+message:
+ Notification message
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view OUTPUT_HELP = R"#(usage: hyprctl [flags] output <create <backend> | remove <name>>
+
+create <backend>:
+ Creates new virtual output. Possible values for backend: wayland, x11,
+ headless or auto.
+
+remove <name>:
+ Removes virtual output. Pass the output's name, as found in
+ 'hyprctl monitors'
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view PLUGIN_HELP = R"#(usage: hyprctl [flags] plugin <request>
+
+requests:
+ load <path> → Loads a plugin. Path must be absolute
+ unload <path> → Unloads a plugin. Path must be absolute
+ list → Lists all loaded plugins
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view SETPROP_HELP = R"#(usage: hyprctl [flags] setprop <regex> <property> <value> [lock]
+
+regex:
+ Regular expression by which a window will be searched
+
+property:
+ See https://wiki.hypr.land/Configuring/Using-hyprctl/#setprop for list
+ of properties
+
+value:
+ Property value
+
+lock:
+ Optional argument. If lock is not added, will be unlocked. Locking means a
+ dynamic windowrule cannot override this setting.
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view GETPROP_HELP = R"#(usage: hyprctl [flags] getprop <regex> <property>
+
+regex:
+ Regular expression by which a window will be searched
+
+property:
+ See https://wiki.hypr.land/Configuring/Using-hyprctl/#setprop for list
+ of properties
+
+flags:
+ See 'hyprctl --help')#";
+
+const std::string_view SWITCHXKBLAYOUT_HELP = R"#(usage: [flags] switchxkblayout <device> <cmd>
+
+device:
+ You can find the device using 'hyprctl devices' command
+
+cmd:
+ 'next' for next, 'prev' for previous, or ID for a specific one. IDs are
+ assigned based on their order in config file (keyboard_layout),
+ starting from 0
+
+flags:
+ See 'hyprctl --help')#";
diff --git a/hyprctl/src/helpers/Memory.hpp b/hyprctl/src/helpers/Memory.hpp
new file mode 100644
index 00000000..1d3a9e07
--- /dev/null
+++ b/hyprctl/src/helpers/Memory.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/memory/UniquePtr.hpp>
+#include <hyprutils/memory/Atomic.hpp>
+
+using namespace Hyprutils::Memory;
+
+#define SP CSharedPointer
+#define WP CWeakPointer
+#define UP CUniquePointer
diff --git a/hyprctl/src/hyprpaper/Hyprpaper.cpp b/hyprctl/src/hyprpaper/Hyprpaper.cpp
new file mode 100644
index 00000000..afa7f653
--- /dev/null
+++ b/hyprctl/src/hyprpaper/Hyprpaper.cpp
@@ -0,0 +1,148 @@
+#include "Hyprpaper.hpp"
+#include "../helpers/Memory.hpp"
+
+#include <optional>
+#include <format>
+#include <filesystem>
+
+#include <hyprpaper_core-client.hpp>
+
+#include <hyprutils/string/VarList2.hpp>
+using namespace Hyprutils::String;
+
+using namespace std::string_literals;
+
+constexpr const char* SOCKET_NAME = ".hyprpaper.sock";
+static SP<CCHyprpaperCoreImpl> g_coreImpl;
+
+constexpr const uint32_t PROTOCOL_VERSION_SUPPORTED = 1;
+
+//
+static hyprpaperCoreWallpaperFitMode fitFromString(const std::string_view& sv) {
+ if (sv == "contain")
+ return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_CONTAIN;
+ if (sv == "fit" || sv == "stretch")
+ return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_STRETCH;
+ if (sv == "tile")
+ return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_TILE;
+ return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_COVER;
+}
+
+static std::expected<std::string, std::string> resolvePath(const std::string_view& sv) {
+ std::error_code ec;
+ auto can = std::filesystem::canonical(sv, ec);
+
+ if (ec)
+ return std::unexpected(std::format("invalid path: {}", ec.message()));
+
+ return can;
+}
+
+static std::expected<std::string, std::string> getFullPath(const std::string_view& sv) {
+ if (sv.empty())
+ return std::unexpected("empty path");
+
+ if (sv[0] == '~') {
+ static auto HOME = getenv("HOME");
+ if (!HOME || HOME[0] == '\0')
+ return std::unexpected("home path but no $HOME");
+
+ return resolvePath(std::string{HOME} + "/"s + std::string{sv.substr(1)});
+ }
+
+ return resolvePath(sv);
+}
+
+std::expected<void, std::string> Hyprpaper::makeHyprpaperRequest(const std::string_view& rq) {
+ if (!rq.contains(' '))
+ return std::unexpected("Invalid request");
+
+ if (!rq.starts_with("/hyprpaper "))
+ return std::unexpected("Invalid request");
+
+ std::string_view LHS, RHS;
+ auto spacePos = rq.find(' ', 12);
+ LHS = rq.substr(11, spacePos - 11);
+ RHS = rq.substr(spacePos + 1);
+
+ if (LHS != "wallpaper")
+ return std::unexpected("Unknown hyprpaper request");
+
+ CVarList2 args(std::string{RHS}, 0, ',');
+
+ const std::string MONITOR = std::string{args[0]};
+ const auto& PATH_RAW = args[1];
+ const auto& FIT = args[2];
+
+ if (PATH_RAW.empty())
+ return std::unexpected("not enough args");
+
+ const auto RTDIR = getenv("XDG_RUNTIME_DIR");
+
+ if (!RTDIR || RTDIR[0] == '\0')
+ return std::unexpected("can't send: no XDG_RUNTIME_DIR");
+
+ const auto HIS = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+ if (!HIS || HIS[0] == '\0')
+ return std::unexpected("can't send: no HYPRLAND_INSTANCE_SIGNATURE (not running under hyprland)");
+
+ const auto PATH = getFullPath(PATH_RAW);
+
+ if (!PATH)
+ return std::unexpected(std::format("bad path: {}", PATH_RAW));
+
+ auto socketPath = RTDIR + "/hypr/"s + HIS + "/"s + SOCKET_NAME;
+
+ auto socket = Hyprwire::IClientSocket::open(socketPath);
+
+ if (!socket)
+ return std::unexpected("can't send: failed to connect to hyprpaper (is it running?)");
+
+ g_coreImpl = makeShared<CCHyprpaperCoreImpl>(1);
+
+ socket->addImplementation(g_coreImpl);
+
+ if (!socket->waitForHandshake())
+ return std::unexpected("can't send: wire handshake failed");
+
+ auto spec = socket->getSpec(g_coreImpl->protocol()->specName());
+
+ if (!spec)
+ return std::unexpected("can't send: hyprpaper doesn't have the spec?!");
+
+ auto manager = makeShared<CCHyprpaperCoreManagerObject>(socket->bindProtocol(g_coreImpl->protocol(), PROTOCOL_VERSION_SUPPORTED));
+
+ if (!manager)
+ return std::unexpected("wire error: couldn't create manager");
+
+ auto wallpaper = makeShared<CCHyprpaperWallpaperObject>(manager->sendGetWallpaperObject());
+
+ if (!wallpaper)
+ return std::unexpected("wire error: couldn't create wallpaper object");
+
+ bool canExit = false;
+ std::optional<std::string> err;
+
+ wallpaper->setFailed([&canExit, &err](uint32_t code) {
+ canExit = true;
+ err = std::format("failed to set wallpaper, code {}", code);
+ });
+ wallpaper->setSuccess([&canExit]() { canExit = true; });
+
+ wallpaper->sendPath(PATH->c_str());
+ wallpaper->sendMonitorName(MONITOR.c_str());
+ if (!FIT.empty())
+ wallpaper->sendFitMode(fitFromString(FIT));
+
+ wallpaper->sendApply();
+
+ while (!canExit) {
+ socket->dispatchEvents(true);
+ }
+
+ if (err)
+ return std::unexpected(*err);
+
+ return {};
+} \ No newline at end of file
diff --git a/hyprctl/src/hyprpaper/Hyprpaper.hpp b/hyprctl/src/hyprpaper/Hyprpaper.hpp
new file mode 100644
index 00000000..167b0a8d
--- /dev/null
+++ b/hyprctl/src/hyprpaper/Hyprpaper.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <expected>
+#include <string>
+
+namespace Hyprpaper {
+ std::expected<void, std::string> makeHyprpaperRequest(const std::string_view& rq);
+}; \ No newline at end of file
diff --git a/hyprctl/src/main.cpp b/hyprctl/src/main.cpp
new file mode 100644
index 00000000..7146c635
--- /dev/null
+++ b/hyprctl/src/main.cpp
@@ -0,0 +1,539 @@
+#include <re2/re2.h>
+
+#include <cctype>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <algorithm>
+#include <csignal>
+#include <ranges>
+#include <optional>
+#include <charconv>
+
+#include <iostream>
+#include <string>
+#include <print>
+#include <fstream>
+#include <vector>
+#include <filesystem>
+#include <cstdarg>
+#include <hyprutils/string/String.hpp>
+#include <hyprutils/memory/Casts.hpp>
+using namespace Hyprutils::String;
+using namespace Hyprutils::Memory;
+
+#include "Strings.hpp"
+#include "hyprpaper/Hyprpaper.hpp"
+
+std::string instanceSignature;
+bool quiet = false;
+
+struct SInstanceData {
+ std::string id;
+ uint64_t time;
+ uint64_t pid;
+ std::string wlSocket;
+};
+
+void log(const std::string_view str) {
+ if (quiet)
+ return;
+
+ std::println("{}", str);
+}
+
+static int getUID() {
+ const auto UID = getuid();
+ const auto PWUID = getpwuid(UID);
+ return PWUID ? PWUID->pw_uid : UID;
+}
+
+std::string getRuntimeDir() {
+ const auto XDG = getenv("XDG_RUNTIME_DIR");
+
+ if (!XDG) {
+ const std::string USERID = std::to_string(getUID());
+ return "/run/user/" + USERID + "/hypr";
+ }
+
+ return std::string{XDG} + "/hypr";
+}
+
+static std::optional<uint64_t> toUInt64(const std::string_view str) {
+ uint64_t value = 0;
+ const auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value);
+ if (ec != std::errc() || ptr != str.data() + str.size())
+ return std::nullopt;
+ return value;
+}
+
+static std::optional<SInstanceData> parseInstance(const std::filesystem::directory_entry& entry) {
+ if (!entry.is_directory())
+ return std::nullopt;
+
+ const auto lockPath = entry.path() / "hyprland.lock";
+ std::ifstream ifs(lockPath);
+ if (!ifs.is_open())
+ return std::nullopt;
+
+ SInstanceData data;
+ data.id = entry.path().filename().string();
+
+ const auto first = std::string_view{data.id}.find_first_of('_');
+ const auto last = std::string_view{data.id}.find_last_of('_');
+ if (first == std::string_view::npos || last == std::string_view::npos || last <= first)
+ return std::nullopt;
+
+ auto time = toUInt64(std::string_view{data.id}.substr(first + 1, last - first - 1));
+ if (!time)
+ return std::nullopt;
+ data.time = *time;
+
+ std::string line;
+ if (!std::getline(ifs, line))
+ return std::nullopt;
+
+ auto pid = toUInt64(std::string_view{line});
+ if (!pid)
+ return std::nullopt;
+ data.pid = *pid;
+
+ if (!std::getline(ifs, data.wlSocket))
+ return std::nullopt;
+
+ if (std::getline(ifs, line) && !line.empty())
+ return std::nullopt; // more lines than expected
+
+ return data;
+}
+
+std::vector<SInstanceData> instances() {
+ std::vector<SInstanceData> result;
+
+ std::error_code ec;
+ const auto runtimeDir = getRuntimeDir();
+ if (!std::filesystem::exists(runtimeDir, ec) || ec)
+ return result;
+
+ std::filesystem::directory_iterator it(runtimeDir, std::filesystem::directory_options::skip_permission_denied, ec);
+ if (ec)
+ return result;
+
+ for (const auto& el : it) {
+ if (auto instance = parseInstance(el))
+ result.emplace_back(std::move(*instance));
+ }
+
+ std::erase_if(result, [](const auto& el) { return kill(el.pid, 0) != 0 && errno == ESRCH; });
+
+ std::ranges::sort(result, {}, &SInstanceData::time);
+
+ return result;
+}
+
+static volatile bool sigintReceived = false;
+void intHandler(int sig) {
+ sigintReceived = true;
+ std::println("[hyprctl] SIGINT received, closing connection");
+}
+
+int rollingRead(const int socket) {
+ sigintReceived = false;
+ signal(SIGINT, intHandler);
+
+ constexpr size_t BUFFER_SIZE = 8192;
+ std::array<char, BUFFER_SIZE> buffer = {0};
+ long sizeWritten = 0;
+ std::println("[hyprctl] reading from socket following up log:");
+ while (!sigintReceived) {
+ sizeWritten = read(socket, buffer.data(), BUFFER_SIZE);
+ if (sizeWritten < 0 && errno != EAGAIN) {
+ if (errno != EINTR)
+ std::println("Couldn't read (5): {}: {}", strerror(errno), errno);
+ close(socket);
+ return 5;
+ }
+
+ if (sizeWritten == 0)
+ break;
+
+ if (sizeWritten > 0) {
+ std::println("{}", std::string(buffer.data(), sizeWritten));
+ buffer.fill('\0');
+ }
+
+ usleep(100000);
+ }
+ close(socket);
+ return 0;
+}
+
+int request(std::string_view arg, int minArgs = 0, bool needRoll = false) {
+ const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+ if (SERVERSOCKET < 0) {
+ log("Couldn't open a socket (1)");
+ return 1;
+ }
+
+ auto t = timeval{.tv_sec = 5, .tv_usec = 0};
+ if (setsockopt(SERVERSOCKET, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0) {
+ log("Couldn't set socket timeout (2)");
+ return 2;
+ }
+
+ const auto ARGS = std::count(arg.begin(), arg.end(), ' ');
+
+ if (ARGS < minArgs) {
+ log(std::format("Not enough arguments in '{}', expected at least {}", arg, minArgs));
+ return -1;
+ }
+
+ if (instanceSignature.empty()) {
+ log("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?) (3)");
+ return 3;
+ }
+
+ sockaddr_un serverAddress = {0};
+ serverAddress.sun_family = AF_UNIX;
+
+ std::string socketPath = getRuntimeDir() + "/" + instanceSignature + "/.socket.sock";
+
+ strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
+
+ if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
+ log("Couldn't connect to " + socketPath + ". (4)");
+ return 4;
+ }
+
+ auto sizeWritten = write(SERVERSOCKET, arg.data(), arg.size());
+
+ if (sizeWritten < 0) {
+ log("Couldn't write (5)");
+ return 5;
+ }
+
+ if (needRoll)
+ return rollingRead(SERVERSOCKET);
+
+ std::string reply = "";
+ constexpr size_t BUFFER_SIZE = 8192;
+ char buffer[BUFFER_SIZE] = {0};
+
+ sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+
+ if (sizeWritten < 0) {
+ if (errno == EWOULDBLOCK)
+ log("Hyprland IPC didn't respond in time\n");
+ log("Couldn't read (6)");
+ return 6;
+ }
+
+ reply += std::string(buffer, sizeWritten);
+
+ while (sizeWritten == BUFFER_SIZE) {
+ sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+ if (sizeWritten < 0) {
+ log("Couldn't read (6)");
+ return 6;
+ }
+ reply += std::string(buffer, sizeWritten);
+ }
+
+ close(SERVERSOCKET);
+
+ log(reply);
+
+ return 0;
+}
+
+int requestIPC(std::string_view filename, std::string_view arg) {
+ const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+ if (SERVERSOCKET < 0) {
+ log("Couldn't open a socket (1)");
+ return 1;
+ }
+
+ if (instanceSignature.empty()) {
+ log("HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)");
+ return 2;
+ }
+
+ sockaddr_un serverAddress = {0};
+ serverAddress.sun_family = AF_UNIX;
+
+ std::string socketPath = getRuntimeDir() + "/" + instanceSignature + "/" + filename;
+
+ strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
+
+ if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
+ log("Couldn't connect to " + socketPath + ". (3)");
+ return 3;
+ }
+
+ arg = arg.substr(arg.find_first_of('/') + 1); // strip flags
+ arg = arg.substr(arg.find_first_of(' ') + 1); // strip "hyprpaper"
+
+ auto sizeWritten = write(SERVERSOCKET, arg.data(), arg.size());
+
+ if (sizeWritten < 0) {
+ log("Couldn't write (4)");
+ return 4;
+ }
+ constexpr size_t BUFFER_SIZE = 8192;
+ char buffer[BUFFER_SIZE] = {0};
+
+ sizeWritten = read(SERVERSOCKET, buffer, BUFFER_SIZE);
+
+ if (sizeWritten < 0) {
+ log("Couldn't read (5)");
+ return 5;
+ }
+
+ close(SERVERSOCKET);
+
+ log(std::string(buffer));
+
+ return 0;
+}
+
+int requestHyprsunset(std::string_view arg) {
+ return requestIPC(".hyprsunset.sock", arg);
+}
+
+void batchRequest(std::string_view arg, bool json) {
+ std::string commands(arg.substr(arg.find_first_of(' ') + 1));
+
+ if (json) {
+ RE2::GlobalReplace(&commands, ";\\s*", ";j/");
+ commands.insert(0, "j/");
+ }
+
+ std::string rq = "[[BATCH]]" + commands;
+ request(rq);
+}
+
+void instancesRequest(bool json) {
+ std::string result = "";
+
+ // gather instance data
+ std::vector<SInstanceData> inst = instances();
+
+ if (!json) {
+ for (auto const& el : inst) {
+ result += std::format("instance {}:\n\ttime: {}\n\tpid: {}\n\twl socket: {}\n\n", el.id, el.time, el.pid, el.wlSocket);
+ }
+ } else {
+ result += '[';
+ for (auto const& el : inst) {
+ result += std::format(R"#(
+{{
+ "instance": "{}",
+ "time": {},
+ "pid": {},
+ "wl_socket": "{}"
+}},)#",
+ el.id, el.time, el.pid, el.wlSocket);
+ }
+
+ result.pop_back();
+ result += "\n]";
+ }
+
+ log(result + "\n");
+}
+
+std::vector<std::string> splitArgs(int argc, char** argv) {
+ std::vector<std::string> result;
+
+ for (auto i = 1 /* skip the executable */; i < argc; ++i)
+ result.emplace_back(argv[i]);
+
+ return result;
+}
+
+int main(int argc, char** argv) {
+ bool parseArgs = true;
+
+ if (argc < 2) {
+ std::println("{}", USAGE);
+ return 1;
+ }
+
+ std::string fullRequest = "";
+ std::string fullArgs = "";
+ const auto ARGS = splitArgs(argc, argv);
+ bool json = false;
+ bool needRoll = false;
+ std::string overrideInstance = "";
+
+ for (std::size_t i = 0; i < ARGS.size(); ++i) {
+ if (ARGS[i] == "--") {
+ // Stop parsing arguments after --
+ parseArgs = false;
+ continue;
+ }
+ if (parseArgs && (ARGS[i][0] == '-') && !(isNumber(ARGS[i], true) || isNumber(ARGS[i].substr(0, ARGS[i].length() - 1), true)) /* For stuff like -2 or -2, */) {
+ // parse
+ if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
+ fullArgs += "j";
+ json = true;
+ } else if (ARGS[i] == "-r" && !fullArgs.contains("r")) {
+ fullArgs += "r";
+ } else if (ARGS[i] == "-a" && !fullArgs.contains("a")) {
+ fullArgs += "a";
+ } else if ((ARGS[i] == "-c" || ARGS[i] == "--config") && !fullArgs.contains("c")) {
+ fullArgs += "c";
+ } else if ((ARGS[i] == "-f" || ARGS[i] == "--follow") && !fullArgs.contains("f")) {
+ fullArgs += "f";
+ needRoll = true;
+ } else if (ARGS[i] == "--batch") {
+ fullRequest = "--batch ";
+ } else if (ARGS[i] == "--instance" || ARGS[i] == "-i") {
+ ++i;
+
+ if (i >= ARGS.size()) {
+ std::println("{}", USAGE);
+ return 1;
+ }
+
+ overrideInstance = ARGS[i];
+ } else if (ARGS[i] == "-q" || ARGS[i] == "--quiet") {
+ quiet = true;
+ } else if (ARGS[i] == "--help") {
+ const std::string& cmd = ARGS[0];
+
+ if (cmd == "hyprpaper") {
+ std::println("{}", HYPRPAPER_HELP);
+ } else if (cmd == "hyprsunset") {
+ std::println("{}", HYPRSUNSET_HELP);
+ } else if (cmd == "notify") {
+ std::println("{}", NOTIFY_HELP);
+ } else if (cmd == "output") {
+ std::println("{}", OUTPUT_HELP);
+ } else if (cmd == "plugin") {
+ std::println("{}", PLUGIN_HELP);
+ } else if (cmd == "setprop") {
+ std::println("{}", SETPROP_HELP);
+ } else if (cmd == "getprop") {
+ std::println("{}", GETPROP_HELP);
+ } else if (cmd == "switchxkblayout") {
+ std::println("{}", SWITCHXKBLAYOUT_HELP);
+ } else {
+ std::println("{}", USAGE);
+ }
+
+ return 1;
+ } else {
+ std::println("{}", USAGE);
+ return 1;
+ }
+
+ continue;
+ }
+
+ fullRequest += ARGS[i] + " ";
+ }
+
+ if (fullRequest.empty()) {
+ std::println("{}", USAGE);
+ return 1;
+ }
+
+ fullRequest.pop_back(); // remove trailing space
+
+ fullRequest = fullArgs + "/" + fullRequest;
+
+ // instances is HIS-independent
+ if (fullRequest.contains("/instances")) {
+ instancesRequest(json);
+ return 0;
+ }
+
+ if (needRoll && !fullRequest.contains("/rollinglog")) {
+ log("only 'rollinglog' command supports '--follow' option");
+ return 1;
+ }
+
+ if (overrideInstance.contains("_"))
+ instanceSignature = overrideInstance;
+ else if (!overrideInstance.empty()) {
+ if (!isNumber(overrideInstance, false)) {
+ log("instance invalid\n");
+ return 1;
+ }
+
+ const auto INSTANCENO = std::stoi(overrideInstance);
+
+ const auto INSTANCES = instances();
+
+ if (INSTANCENO < 0 || sc<std::size_t>(INSTANCENO) >= INSTANCES.size()) {
+ log("no such instance\n");
+ return 1;
+ }
+
+ instanceSignature = INSTANCES[INSTANCENO].id;
+ } else {
+ const auto ISIG = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+ if (!ISIG) {
+ log("HYPRLAND_INSTANCE_SIGNATURE not set! (is hyprland running?)\n");
+ return 1;
+ }
+
+ instanceSignature = ISIG;
+ }
+
+ int exitStatus = 0;
+
+ if (fullRequest.contains("/--batch"))
+ batchRequest(fullRequest, json);
+ else if (fullRequest.contains("/hyprpaper")) {
+ auto result = Hyprpaper::makeHyprpaperRequest(fullRequest);
+ if (!result)
+ log(std::format("error: {}", result.error()));
+ exitStatus = !result;
+ } else if (fullRequest.contains("/hyprsunset"))
+ exitStatus = requestHyprsunset(fullRequest);
+ else if (fullRequest.contains("/switchxkblayout"))
+ exitStatus = request(fullRequest, 2);
+ else if (fullRequest.contains("/seterror"))
+ exitStatus = request(fullRequest, 1);
+ else if (fullRequest.contains("/setprop"))
+ exitStatus = request(fullRequest, 3);
+ else if (fullRequest.contains("/plugin"))
+ exitStatus = request(fullRequest, 1);
+ else if (fullRequest.contains("/dismissnotify"))
+ exitStatus = request(fullRequest, 0);
+ else if (fullRequest.contains("/notify"))
+ exitStatus = request(fullRequest, 2);
+ else if (fullRequest.contains("/output"))
+ exitStatus = request(fullRequest, 2);
+ else if (fullRequest.contains("/setcursor"))
+ exitStatus = request(fullRequest, 1);
+ else if (fullRequest.contains("/dispatch"))
+ exitStatus = request(fullRequest, 1);
+ else if (fullRequest.contains("/keyword"))
+ exitStatus = request(fullRequest, 2);
+ else if (fullRequest.contains("/decorations"))
+ exitStatus = request(fullRequest, 1);
+ else if (fullRequest.contains("/--help"))
+ std::println("{}", USAGE);
+ else if (fullRequest.contains("/rollinglog") && needRoll)
+ exitStatus = request(fullRequest, 0, true);
+ else {
+ exitStatus = request(fullRequest);
+ }
+
+ std::cout << std::flush;
+ return exitStatus;
+}