diff --git a/README.md b/README.md index dd2ea59e..6c07e8fc 100644 --- a/README.md +++ b/README.md @@ -8,10 +8,10 @@ Vesktop is a custom Discord desktop app - Much more lightweight and faster than the official Discord app - Linux Screenshare with sound & wayland - Much better privacy, since Discord has no access to your system +- Global keybinds, including push to talk (see [Global Keybinds](#global-keybinds)) **Not yet supported**: -- Global Keybinds - see the [Roadmap](https://github.com/Vencord/Vesktop/issues/324) ![](https://github.com/Vencord/Vesktop/assets/45497981/8608a899-96a9-4027-9725-2cb02ba189fd) @@ -21,6 +21,31 @@ Vesktop is a custom Discord desktop app Visit https://vesktop.dev/install +## Global Keybinds + +Configure them in the Vesktop settings, or from Discord's Keybinds and Voice & Video settings. + +- **Windows, Linux (X11)**: Bind any keys or mouse buttons in the Vesktop keybind settings +- **macOS**: Same as above, but Vesktop needs the Accessibility permission +- **Linux (Wayland)**: Wayland doesn't let apps listen to global input. Enable global shortcuts in the Vesktop keybind settings and assign them in your system settings. This requires a desktop that supports the GlobalShortcuts portal, like GNOME or KDE + +You can also trigger actions from other programs, for example your compositor's keybinds: + +```sh +vesktop --run-shortcut toggleMute +# Append :down or :up to only press or release, e.g. for push to talk +vesktop --run-shortcut pushToTalk:down +vesktop --run-shortcut pushToTalk:up +``` + +For lower latency, send the same commands as lines to the socket at `$XDG_RUNTIME_DIR/vesktop.sock`: + +```sh +echo "run-shortcut pushToTalk:down" | socat - UNIX-CONNECT:$XDG_RUNTIME_DIR/vesktop.sock +``` + +Run `vesktop --help` to see all actions. + ## Building from Source You need to have the following dependencies installed: diff --git a/package.json b/package.json index 634139d2..91d56ebb 100644 --- a/package.json +++ b/package.json @@ -27,7 +27,8 @@ "generateMeta": "tsx scripts/utils/generateMeta.mts" }, "dependencies": { - "electron-updater": "6.6.2" + "electron-updater": "6.6.2", + "uiohook-napi": "^1.5.5" }, "optionalDependencies": { "@vencord/venmic": "^7.2.5" diff --git a/packages/libvesktop/index.d.ts b/packages/libvesktop/index.d.ts index 96544193..175832e7 100644 --- a/packages/libvesktop/index.d.ts +++ b/packages/libvesktop/index.d.ts @@ -1,2 +1,29 @@ export function requestBackground(autoStart: boolean, commandLine: string[]): boolean; export function isStatusNotifierHostRegistered(): boolean; +export function registerHostApp(appId: string): boolean; +export function openGnomeAppSettings(appId: string): boolean; + +export interface XDPShortcut { + id: string; + description: string; +} + +export interface XDPBoundShortcut extends XDPShortcut { + trigger: string; +} + +export type XDPGlobalShortcutsEvent = + | [event: "version", version: number] + | [event: "ready"] + | [event: "fatal", message: string] + | [event: "error", message: string] + | [event: "shortcuts", shortcuts: XDPBoundShortcut[]] + | [event: "shortcut", id: string, pressed: boolean]; + +export class XDPGlobalShortcuts { + constructor(onEvent: (...args: XDPGlobalShortcutsEvent) => void); + + bindShortcuts(shortcuts: XDPShortcut[]): void; + configureShortcuts(): void; + destroy(): void; +} diff --git a/packages/libvesktop/src/libvesktop.cc b/packages/libvesktop/src/libvesktop.cc index 3d1339f1..575ea0dd 100644 --- a/packages/libvesktop/src/libvesktop.cc +++ b/packages/libvesktop/src/libvesktop.cc @@ -1,8 +1,13 @@ #include +#include #include +#include #include +#include #include #include +#include +#include template struct GObjectDeleter @@ -39,6 +44,29 @@ struct GErrorDeleter using GErrorPtr = std::unique_ptr; +struct SignalSubscription { + SignalSubscription() = default; + SignalSubscription(GDBusConnection *conn, guint id) : conn_(conn), id_(id) {} + ~SignalSubscription() { reset(); } + + SignalSubscription(const SignalSubscription &) = delete; + SignalSubscription &operator=(const SignalSubscription &) = delete; + + SignalSubscription(SignalSubscription &&o) noexcept : conn_(o.conn_), id_(o.id_) { o.id_ = 0; } + SignalSubscription &operator=(SignalSubscription &&o) noexcept { + if (this != &o) { reset(); conn_ = o.conn_; id_ = o.id_; o.id_ = 0; } + return *this; + } + + void reset() { + if (id_) { g_dbus_connection_signal_unsubscribe(conn_, id_); id_ = 0; }} + explicit operator bool() const { return id_ != 0; } + +private: + GDBusConnection *conn_ = nullptr; + guint id_ = 0; +}; + bool request_background(bool autostart, const std::vector &commandline) { GError *error = nullptr; @@ -158,10 +186,498 @@ Napi::Value IsStatusNotifierHostRegistered(const Napi::CallbackInfo &info) return Napi::Boolean::New(info.Env(), is_status_notifier_host_registered()); } + +constexpr const char *PORTAL_BUS_NAME = "org.freedesktop.portal.Desktop"; +constexpr const char *PORTAL_PATH = "/org/freedesktop/portal/desktop"; +constexpr const char *SHORTCUTS_INTERFACE = "org.freedesktop.portal.GlobalShortcuts"; + +// Tells the portal our app id. Unsandboxed apps otherwise have an empty app id, which portals use to persist things like shortcut triggers. +// Must happen before any other portal call on this connection. +bool register_host_app(const std::string &app_id) +{ + GError *error = nullptr; + + GObjectPtr bus(g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error)); + if (!bus) + { + GErrorPtr error_ptr(error); + return false; + } + + GVariantBuilder options; + g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); + + GVariantPtr reply(g_dbus_connection_call_sync( + bus.get(), + PORTAL_BUS_NAME, + PORTAL_PATH, + "org.freedesktop.host.portal.Registry", + "Register", + g_variant_new("(sa{sv})", app_id.c_str(), &options), + nullptr, + G_DBUS_CALL_FLAGS_NONE, + 1000, + nullptr, + &error)); + + if (!reply) + { + GErrorPtr error_ptr(error); + std::cerr << "[libvesktop::register_host_app] Failed to register app id: " + << (error_ptr ? error_ptr->message : "unknown error") << std::endl; + return false; + } + + // The registration belongs to this connection's unique name. The shared bus connection is only weakly cached by GLib, + // so keep it alive forever to not lose the registration once all other references are dropped + bus.release(); + return true; +} + +Napi::Value RegisterHostApp(const Napi::CallbackInfo &info) +{ + Napi::Env env = info.Env(); + + if (info.Length() < 1 || !info[0].IsString()) + { + Napi::TypeError::New(env, "Expected (string)").ThrowAsJavaScriptException(); + return env.Null(); + } + + return Napi::Boolean::New(env, register_host_app(info[0].As().Utf8Value())); +} + +// Opens GNOME Settings on the page of the given app, which is where GNOME lets you change its global shortcuts +bool open_gnome_app_settings(const std::string &app_id) +{ + GError *error = nullptr; + + GObjectPtr bus(g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error)); + if (!bus) + { + GErrorPtr error_ptr(error); + return false; + } + + GVariantBuilder panel_args; + g_variant_builder_init(&panel_args, G_VARIANT_TYPE("av")); + g_variant_builder_add(&panel_args, "v", g_variant_new_string(app_id.c_str())); + + GVariantBuilder action_params; + g_variant_builder_init(&action_params, G_VARIANT_TYPE("av")); + g_variant_builder_add(&action_params, "v", g_variant_new("(sav)", "applications", &panel_args)); + + GVariantBuilder platform_data; + g_variant_builder_init(&platform_data, G_VARIANT_TYPE_VARDICT); + + GVariantPtr reply(g_dbus_connection_call_sync( + bus.get(), + "org.gnome.Settings", + "/org/gnome/Settings", + "org.freedesktop.Application", + "ActivateAction", + g_variant_new("(sava{sv})", "launch-panel", &action_params, &platform_data), + nullptr, + G_DBUS_CALL_FLAGS_NONE, + 5000, + nullptr, + &error)); + + if (!reply) + { + GErrorPtr error_ptr(error); + std::cerr << "[libvesktop::open_gnome_app_settings] Failed to open GNOME Settings: " + << (error_ptr ? error_ptr->message : "unknown error") << std::endl; + return false; + } + + return true; +} + +Napi::Value OpenGnomeAppSettings(const Napi::CallbackInfo &info) +{ + Napi::Env env = info.Env(); + + if (info.Length() < 1 || !info[0].IsString()) + { + Napi::TypeError::New(env, "Expected (string)").ThrowAsJavaScriptException(); + return env.Null(); + } + + return Napi::Boolean::New(env, open_gnome_app_settings(info[0].As().Utf8Value())); +} + +// org.freedesktop.portal.GlobalShortcuts session. Reports everything through the callback passed to the constructor: +// ("version", number), ("ready"), ("fatal", message), ("error", message), +// ("shortcuts", { id, description, trigger }[]), ("shortcut", id, pressed) +class XDPGlobalShortcuts : public Napi::ObjectWrap +{ +public: + static void Init(Napi::Env env, Napi::Object exports) + { + exports.Set("XDPGlobalShortcuts", DefineClass(env, "XDPGlobalShortcuts", { + InstanceMethod("bindShortcuts", &XDPGlobalShortcuts::BindShortcuts), + InstanceMethod("configureShortcuts", &XDPGlobalShortcuts::ConfigureShortcuts), + InstanceMethod("destroy", &XDPGlobalShortcuts::Destroy), + })); + } + + XDPGlobalShortcuts(const Napi::CallbackInfo &info) : ObjectWrap(info) + { + Napi::Env env = info.Env(); + + if (info.Length() < 1 || !info[0].IsFunction()) + { + Napi::TypeError::New(env, "Expected (function)").ThrowAsJavaScriptException(); + return; + } + + GError *error = nullptr; + connection_.reset(g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error)); + if (!connection_) + { + GErrorPtr error_ptr(error); + Napi::Error::New(env, error_ptr ? error_ptr->message : "Failed to connect to session bus") + .ThrowAsJavaScriptException(); + return; + } + + // Request objects live at /org/freedesktop/portal/desktop/request/SENDER/TOKEN, where SENDER is our unique name (":1.23" -> "1_23") + std::string sender = g_dbus_connection_get_unique_name(connection_.get()) + 1; + std::replace(sender.begin(), sender.end(), '.', '_'); + requestPathPrefix_ = std::string(PORTAL_PATH) + "/request/" + sender + "/"; + + cancellable_.reset(g_cancellable_new()); + tsfn_ = Napi::ThreadSafeFunction::New(env, info[0].As(), "libvesktop-global-shortcuts", 0, 1); + active_ = true; + + FetchVersion(); + SubscribeSignals(); + CreateSession(); + } + + ~XDPGlobalShortcuts() override { Cleanup(); } + +private: + using ArgFactory = std::function; + using ReplyCallback = std::function; + using ResponseCallback = std::function; + using SignalCallback = std::function; + + GObjectPtr connection_; + GObjectPtr cancellable_; + Napi::ThreadSafeFunction tsfn_; + bool active_ = false; + std::string requestPathPrefix_; + std::string session_; + // Tokens must be unique per connection, so shared between all instances + static inline guint32 nextToken_ = 0; + std::map requests_; + std::vector signals_; + + Napi::Value BindShortcuts(const Napi::CallbackInfo &info) + { + Napi::Env env = info.Env(); + + if (info.Length() < 1 || !info[0].IsArray()) + { + Napi::TypeError::New(env, "Expected ({ id: string, description: string }[])").ThrowAsJavaScriptException(); + return env.Undefined(); + } + if (session_.empty()) + { + Napi::Error::New(env, "Session is not ready").ThrowAsJavaScriptException(); + return env.Undefined(); + } + + GVariantBuilder shortcuts; + g_variant_builder_init(&shortcuts, G_VARIANT_TYPE("a(sa{sv})")); + + Napi::Array arr = info[0].As(); + for (uint32_t i = 0; i < arr.Length(); i++) + { + Napi::Object item = arr.Get(i).As(); + std::string id = item.Get("id").ToString().Utf8Value(); + std::string description = item.Get("description").ToString().Utf8Value(); + + GVariantBuilder props; + g_variant_builder_init(&props, G_VARIANT_TYPE_VARDICT); + g_variant_builder_add(&props, "{sv}", "description", g_variant_new_string(description.c_str())); + g_variant_builder_add(&shortcuts, "(sa{sv})", id.c_str(), &props); + } + + std::string token = NewToken(); + GVariantBuilder options; + g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); + g_variant_builder_add(&options, "{sv}", "handle_token", g_variant_new_string(token.c_str())); + + Request("BindShortcuts", token, + g_variant_new("(oa(sa{sv})sa{sv})", session_.c_str(), &shortcuts, "", &options), + "error", + [this](guint32 response, GVariant *results) { + if (response != 0) + { + Emit("error", {Str(response == 1 ? "Binding shortcuts was cancelled" : "Failed to bind shortcuts")}); + return; + } + + GVariantPtr bound(g_variant_lookup_value(results, "shortcuts", G_VARIANT_TYPE("a(sa{sv})"))); + Emit("shortcuts", {ParseShortcuts(bound.get())}); + }); + + return env.Undefined(); + } + + Napi::Value ConfigureShortcuts(const Napi::CallbackInfo &info) + { + if (session_.empty()) + { + Napi::Error::New(info.Env(), "Session is not ready").ThrowAsJavaScriptException(); + return info.Env().Undefined(); + } + + GVariantBuilder options; + g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); + + Call(PORTAL_PATH, SHORTCUTS_INTERFACE, "ConfigureShortcuts", + g_variant_new("(osa{sv})", session_.c_str(), "", &options), + nullptr, + [this](GVariant *, GError *error) { + if (error) + Emit("error", {Str(std::string("ConfigureShortcuts: ") + error->message)}); + }); + + return info.Env().Undefined(); + } + + Napi::Value Destroy(const Napi::CallbackInfo &info) + { + Cleanup(); + return info.Env().Undefined(); + } + + void Cleanup() + { + if (!active_) + return; + active_ = false; + + g_cancellable_cancel(cancellable_.get()); + requests_.clear(); + signals_.clear(); + + if (!session_.empty()) + { + g_dbus_connection_call(connection_.get(), PORTAL_BUS_NAME, session_.c_str(), "org.freedesktop.portal.Session", + "Close", nullptr, nullptr, G_DBUS_CALL_FLAGS_NONE, -1, nullptr, nullptr, nullptr); + session_.clear(); + } + + tsfn_.Release(); + } + + void FetchVersion() + { + Call(PORTAL_PATH, "org.freedesktop.DBus.Properties", "Get", + g_variant_new("(ss)", SHORTCUTS_INTERFACE, "version"), + G_VARIANT_TYPE("(v)"), + [this](GVariant *reply, GError *) { + guint32 version = 0; + if (reply) + { + GVariant *raw = nullptr; + g_variant_get(reply, "(v)", &raw); + GVariantPtr value(raw); + if (g_variant_is_of_type(value.get(), G_VARIANT_TYPE_UINT32)) + version = g_variant_get_uint32(value.get()); + } + Emit("version", {[version](Napi::Env env) -> Napi::Value { return Napi::Number::New(env, version); }}); + }); + } + + void CreateSession() + { + std::string token = NewToken(); + GVariantBuilder options; + g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); + g_variant_builder_add(&options, "{sv}", "handle_token", g_variant_new_string(token.c_str())); + g_variant_builder_add(&options, "{sv}", "session_handle_token", g_variant_new_string(token.c_str())); + + Request("CreateSession", token, g_variant_new("(a{sv})", &options), "fatal", + [this](guint32 response, GVariant *results) { + // Older portal versions send the handle as a string, newer as an object path + GVariantPtr handle(g_variant_lookup_value(results, "session_handle", nullptr)); + if (response != 0 || !handle || + !(g_variant_is_of_type(handle.get(), G_VARIANT_TYPE_STRING) || + g_variant_is_of_type(handle.get(), G_VARIANT_TYPE_OBJECT_PATH))) + { + Emit("fatal", {Str("Failed to create session (response " + std::to_string(response) + ")")}); + return; + } + + session_ = g_variant_get_string(handle.get(), nullptr); + Emit("ready"); + }); + } + + void SubscribeSignals() + { + auto onKey = [this](bool pressed) { + return [this, pressed](GVariant *parameters) { + const char *session = nullptr; + const char *id = nullptr; + guint64 timestamp = 0; + g_variant_get(parameters, "(&o&sta{sv})", &session, &id, ×tamp, nullptr); + if (session_ != session) + return; + + Emit("shortcut", {Str(id), [pressed](Napi::Env env) -> Napi::Value { return Napi::Boolean::New(env, pressed); }}); + }; + }; + + signals_.push_back(Subscribe(SHORTCUTS_INTERFACE, "Activated", PORTAL_PATH, onKey(true))); + signals_.push_back(Subscribe(SHORTCUTS_INTERFACE, "Deactivated", PORTAL_PATH, onKey(false))); + signals_.push_back(Subscribe(SHORTCUTS_INTERFACE, "ShortcutsChanged", PORTAL_PATH, [this](GVariant *parameters) { + const char *session = nullptr; + GVariant *raw = nullptr; + g_variant_get(parameters, "(&o@a(sa{sv}))", &session, &raw); + GVariantPtr shortcuts(raw); + if (session_ == session) + Emit("shortcuts", {ParseShortcuts(shortcuts.get())}); + })); + } + + std::string NewToken() { return "vesktop" + std::to_string(++nextToken_); } + + void Call(const char *path, const char *interface, const char *method, GVariant *params, + const GVariantType *replyType, ReplyCallback callback) + { + g_dbus_connection_call( + connection_.get(), PORTAL_BUS_NAME, path, interface, method, params, replyType, + G_DBUS_CALL_FLAGS_NONE, -1, cancellable_.get(), + [](GObject *source, GAsyncResult *res, gpointer user_data) { + std::unique_ptr callback(static_cast(user_data)); + GError *raw_error = nullptr; + GVariantPtr reply(g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &raw_error)); + GErrorPtr error(raw_error); + + // Cancelled means we were destroyed, so the callback must not run + if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) + (*callback)(reply.get(), error.get()); + }, + new ReplyCallback(std::move(callback))); + } + + // Calls a portal method that answers asynchronously with a Request::Response signal + void Request(const char *method, const std::string &token, GVariant *params, const char *errorEvent, + ResponseCallback onResponse) + { + requests_[token] = Subscribe("org.freedesktop.portal.Request", "Response", (requestPathPrefix_ + token).c_str(), + [this, token, onResponse](GVariant *parameters) { + guint32 response = 2; + GVariant *raw = nullptr; + g_variant_get(parameters, "(u@a{sv})", &response, &raw); + GVariantPtr results(raw); + + // Erasing unsubscribes this handler, so copy what we need first + ResponseCallback callback = onResponse; + std::string key = token; + requests_.erase(key); + callback(response, results.get()); + }); + + Call(PORTAL_PATH, SHORTCUTS_INTERFACE, method, params, G_VARIANT_TYPE("(o)"), + [this, token, method = std::string(method), errorEvent = std::string(errorEvent)](GVariant *, GError *error) { + if (!error) + return; + requests_.erase(token); + Emit(errorEvent, {Str(method + ": " + error->message)}); + }); + } + + SignalSubscription Subscribe(const char *interface, const char *signal, const char *path, SignalCallback callback) + { + guint id = g_dbus_connection_signal_subscribe( + connection_.get(), PORTAL_BUS_NAME, interface, signal, path, nullptr, G_DBUS_SIGNAL_FLAGS_NONE, + [](GDBusConnection *, const char *, const char *, const char *, const char *, GVariant *parameters, + gpointer user_data) { (*static_cast(user_data))(parameters); }, + new SignalCallback(std::move(callback)), + [](gpointer user_data) { delete static_cast(user_data); }); + + return {connection_.get(), id}; + } + + void Emit(std::string name, std::vector args = {}) + { + if (!active_) + return; + + using Event = std::pair>; + tsfn_.NonBlockingCall(new Event(std::move(name), std::move(args)), + [](Napi::Env env, Napi::Function callback, Event *event) { + std::unique_ptr owned(event); + if (env == nullptr) + return; + + std::vector values{Napi::String::New(env, owned->first)}; + for (auto &make : owned->second) + values.push_back(make(env)); + callback.Call(values); + }); + } + + static ArgFactory Str(std::string value) + { + return [value = std::move(value)](Napi::Env env) -> Napi::Value { return Napi::String::New(env, value); }; + } + + static ArgFactory ParseShortcuts(GVariant *shortcuts) + { + struct Shortcut + { + std::string id, description, trigger; + }; + std::vector parsed; + + if (shortcuts) + { + GVariantIter iter; + g_variant_iter_init(&iter, shortcuts); + const char *id = nullptr; + GVariant *raw = nullptr; + while (g_variant_iter_next(&iter, "(&s@a{sv})", &id, &raw)) + { + GVariantPtr props(raw); + const char *description = ""; + const char *trigger = ""; + g_variant_lookup(props.get(), "description", "&s", &description); + g_variant_lookup(props.get(), "trigger_description", "&s", &trigger); + parsed.push_back({id, description, trigger}); + } + } + + return [parsed = std::move(parsed)](Napi::Env env) -> Napi::Value { + Napi::Array arr = Napi::Array::New(env, parsed.size()); + for (size_t i = 0; i < parsed.size(); i++) + { + Napi::Object obj = Napi::Object::New(env); + obj.Set("id", parsed[i].id); + obj.Set("description", parsed[i].description); + obj.Set("trigger", parsed[i].trigger); + arr.Set(i, obj); + } + return arr; + }; + } +}; + Napi::Object Init(Napi::Env env, Napi::Object exports) { exports.Set("requestBackground", Napi::Function::New(env, RequestBackground)); exports.Set("isStatusNotifierHostRegistered", Napi::Function::New(env, IsStatusNotifierHostRegistered)); + exports.Set("registerHostApp", Napi::Function::New(env, RegisterHostApp)); + exports.Set("openGnomeAppSettings", Napi::Function::New(env, OpenGnomeAppSettings)); + XDPGlobalShortcuts::Init(env, exports); return exports; } diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 0d60e3e1..e7d16775 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -172,6 +172,9 @@ importers: electron-updater: specifier: 6.6.2 version: 6.6.2(patch_hash=080505564abb2ebbda932bbf8fe91540c74dd905de994888d52ffce6f882f887)(supports-color@7.2.0) + uiohook-napi: + specifier: ^1.5.5 + version: 1.5.5 devDependencies: '@fal-works/esbuild-plugin-global-externals': specifier: ^2.1.2 @@ -1808,6 +1811,10 @@ packages: node-api-version@0.2.1: resolution: {integrity: sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==} + node-gyp-build@4.8.4: + resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==} + hasBin: true + node-gyp@11.5.0: resolution: {integrity: sha512-ra7Kvlhxn5V9Slyus0ygMa2h+UqExPqUIkfk7Pc8QTLT956JLSy51uWFwHtIYy0vI8cB4BDhc/S03+880My/LQ==} engines: {node: ^18.17.0 || >=20.5.0} @@ -2241,6 +2248,10 @@ packages: engines: {node: '>=14.17'} hasBin: true + uiohook-napi@1.5.5: + resolution: {integrity: sha512-oSlTdnECw2GBfsJPTbBQBeE4v/EXP0EZmX6BJq5nzH/JgFaBE8JpFwEA/kLhiEP7HxQw28FViWiYgdIZzWuuJQ==} + engines: {node: '>= 16'} + undici-types@7.24.6: resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==} @@ -3989,6 +4000,8 @@ snapshots: dependencies: semver: 7.8.5 + node-gyp-build@4.8.4: {} + node-gyp@11.5.0(supports-color@7.2.0): dependencies: env-paths: 2.2.1 @@ -4455,6 +4468,10 @@ snapshots: typescript@6.0.3: {} + uiohook-napi@1.5.5: + dependencies: + node-gyp-build: 4.8.4 + undici-types@7.24.6: {} undici-types@8.9.0: {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 9b597b82..c4ae33c2 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -6,6 +6,7 @@ allowBuilds: electron: true electron-winstaller: false esbuild: true + uiohook-napi: true pmOnFail: warn verifyDepsBeforeRun: warn recursiveInstall: false diff --git a/scripts/build/build.mts b/scripts/build/build.mts index 852c5d1a..0f24f326 100644 --- a/scripts/build/build.mts +++ b/scripts/build/build.mts @@ -6,7 +6,7 @@ import { copyFile, rm } from "fs/promises"; -import { BuildContext, BuildOptions, context } from "esbuild"; +import { BuildContext, BuildOptions, context, Plugin } from "esbuild"; import { includeDirPlugin } from "./includeDirPlugin.mts"; import vencordDep from "./vencordDep.mjs"; @@ -34,6 +34,29 @@ const NodeCommonOpts: BuildOptions = { } }; +// uiohook-napi finds its binary with node-gyp-build, so point that at the copy in static/dist (see copyUiohook) +const uiohookBinaryPlugin: Plugin = { + name: "uiohook-binary", + setup(build) { + build.onResolve({ filter: /^node-gyp-build$/ }, args => { + if (args.importer.includes("uiohook-napi")) return { path: "uiohook-binary", namespace: "uiohook-binary" }; + }); + build.onLoad({ filter: /.*/, namespace: "uiohook-binary" }, () => ({ + contents: ` + const { join } = require("path"); + module.exports = () => require(join(__dirname, "../../static/dist/uiohook-napi-" + process.arch + ".node")); + `, + loader: "js" + })); + } +}; + +// Overwriting in place crashes a running instance, as the addon is mapped into memory, so replace the file instead +async function copyNativeModule(src: string, dest: string) { + await rm(dest, { force: true }); + await copyFile(src, dest); +} + const contexts = [] as BuildContext[]; async function createContext(options: BuildOptions) { contexts.push(await context(options)); @@ -43,27 +66,40 @@ async function copyVenmic() { if (process.platform !== "linux") return; return Promise.all([ - copyFile( + copyNativeModule( "./node_modules/@vencord/venmic/prebuilds/venmic-addon-linux-x64/node-napi-v7.node", "./static/dist/venmic-x64.node" ), - copyFile( + copyNativeModule( "./node_modules/@vencord/venmic/prebuilds/venmic-addon-linux-arm64/node-napi-v7.node", "./static/dist/venmic-arm64.node" ) ]).catch(() => console.warn("Failed to copy venmic. Building without venmic support")); } +async function copyUiohook() { + const prebuilds = "./node_modules/uiohook-napi/prebuilds"; + + return Promise.all( + ["x64", "arm64"].map(arch => + copyNativeModule( + `${prebuilds}/${process.platform}-${arch}/uiohook-napi.node`, + `./static/dist/uiohook-napi-${arch}.node` + ) + ) + ).catch(() => console.warn("Failed to copy uiohook. Building without global keybind support")); +} + async function copyGameDetection() { const prebuilds = "./node_modules/@vencord/game-detection/prebuilds"; return Promise.all( - ["x64", "arm64"].map(async arch => { - const dest = `./static/dist/game-detection-${arch}.node`; - // Overwriting in place crashes a running instance, as the addon is mapped into memory - await rm(dest, { force: true }); - await copyFile(`${prebuilds}/${process.platform}-${arch}/rpc_native.node`, dest); - }) + ["x64", "arm64"].map(arch => + copyNativeModule( + `${prebuilds}/${process.platform}-${arch}/rpc_native.node`, + `./static/dist/game-detection-${arch}.node` + ) + ) ).catch(() => console.warn("Failed to copy game detection. Building without game detection support")); } @@ -71,7 +107,7 @@ async function copyLibVesktop() { if (process.platform !== "linux") return; try { - await copyFile( + await copyNativeModule( "./packages/libvesktop/build/Release/vesktop.node", `./static/dist/libvesktop-${process.arch}.node` ); @@ -81,8 +117,11 @@ async function copyLibVesktop() { "Using prebuilt libvesktop binaries. Run `pnpm buildLibVesktop` and build again to build from source - see README.md for more details" ); return Promise.all([ - copyFile("./packages/libvesktop/prebuilds/vesktop-x64.node", "./static/dist/libvesktop-x64.node"), - copyFile("./packages/libvesktop/prebuilds/vesktop-arm64.node", "./static/dist/libvesktop-arm64.node") + copyNativeModule("./packages/libvesktop/prebuilds/vesktop-x64.node", "./static/dist/libvesktop-x64.node"), + copyNativeModule( + "./packages/libvesktop/prebuilds/vesktop-arm64.node", + "./static/dist/libvesktop-arm64.node" + ) ]).catch(() => console.warn("Failed to copy libvesktop. Building without libvesktop support")); } } @@ -91,9 +130,11 @@ await Promise.all([ copyVenmic(), copyLibVesktop(), copyGameDetection(), + copyUiohook(), createContext({ ...NodeCommonOpts, entryPoints: ["src/main/index.ts"], + plugins: [uiohookBinaryPlugin], outfile: "dist/js/main.js", footer: { js: "//# sourceURL=VesktopMain" } }), diff --git a/src/main/cli.ts b/src/main/cli.ts index 0a1a5400..70e95afc 100644 --- a/src/main/cli.ts +++ b/src/main/cli.ts @@ -8,6 +8,7 @@ import { basename } from "path"; import { parseArgs, ParseArgsOptionDescriptor } from "util"; import { app } from "electron"; +import { parseShortcutCommand, SHORTCUT_ACTIONS } from "shared/utils/keybind"; import { stripIndent } from "shared/utils/text"; type Option = ParseArgsOptionDescriptor & { @@ -44,6 +45,11 @@ const options = { description: "Set User-Agent to a specific operating system. May trigger anti-spam or break voice chat", options: ["windows", "linux", "darwin"] }, + "run-shortcut": { + type: "string", + description: `Trigger a keybind action in the running instance. Append :down or :up to only press or release it (e.g. for push to talk). Actions: ${SHORTCUT_ACTIONS.join(", ")}`, + argumentName: "action[:down|:up]" + }, repair: { type: "boolean", description: "Repair the application by re-downloading the latest Vencord files" @@ -145,6 +151,15 @@ export function checkCommandLineForHelpOrVersion() { app.exit(1); } } + + const runShortcut = CommandLine.values["run-shortcut"]; + if (runShortcut && !parseShortcutCommand(runShortcut)) { + console.error( + `Invalid value for --run-shortcut: ${runShortcut}\nExpected one of: ${SHORTCUT_ACTIONS.join(", ")}` + ); + console.error("Optionally followed by :down or :up"); + app.exit(1); + } } checkCommandLineForHelpOrVersion(); diff --git a/src/main/constants.ts b/src/main/constants.ts index 910285ad..477792a5 100644 --- a/src/main/constants.ts +++ b/src/main/constants.ts @@ -5,6 +5,7 @@ */ import { existsSync, mkdirSync, rmSync } from "fs"; +import { tmpdir, userInfo } from "os"; import { dirname, join } from "path"; import { app } from "electron"; @@ -73,3 +74,20 @@ export const enum MessageBoxChoice { } export const IS_FLATPAK = process.env.FLATPAK_ID !== undefined; + +export const IS_WAYLAND = + process.platform === "linux" && (process.env.XDG_SESSION_TYPE === "wayland" || !!process.env.WAYLAND_DISPLAY); + +function getSocketPath() { + if (process.platform === "win32") return `\\\\.\\pipe\\vesktop-${userInfo().username}`; + + const { XDG_RUNTIME_DIR, FLATPAK_ID } = process.env; + if (!XDG_RUNTIME_DIR) return join(tmpdir(), `vesktop-${userInfo().uid}.sock`); + + // Only $XDG_RUNTIME_DIR/app/$FLATPAK_ID is shared with the host + return FLATPAK_ID + ? join(XDG_RUNTIME_DIR, "app", FLATPAK_ID, "vesktop.sock") + : join(XDG_RUNTIME_DIR, "vesktop.sock"); +} + +export const SOCKET_PATH = getSocketPath(); diff --git a/src/main/dbus.ts b/src/main/dbus.ts index a31dbc87..2a1e3754 100644 --- a/src/main/dbus.ts +++ b/src/main/dbus.ts @@ -6,14 +6,23 @@ import { join } from "path"; +import type { XDPGlobalShortcutsEvent } from "libvesktop"; import { STATIC_DIR } from "shared/paths"; +import { IS_FLATPAK } from "./constants"; + +// Name of our .desktop file, which portals and GNOME identify us by +const APP_ID = process.env.FLATPAK_ID ?? "vesktop"; + let libVesktop: typeof import("libvesktop") | null = null; function loadLibVesktop() { try { if (!libVesktop) { - libVesktop = require(join(STATIC_DIR, `dist/libvesktop-${process.arch}.node`)); + libVesktop = require( + join(STATIC_DIR, `dist/libvesktop-${process.arch}.node`) + ) as typeof import("libvesktop"); + if (!IS_FLATPAK) libVesktop.registerHostApp(APP_ID); } } catch (e) { console.error("Failed to load libvesktop:", e); @@ -29,3 +38,14 @@ export function requestBackground(autoStart: boolean, commandLine: string[]) { export function isStatusNotifierHostRegistered() { return loadLibVesktop()?.isStatusNotifierHostRegistered() ?? true; } + +export function createXDPGlobalShortcuts(onEvent: (...args: XDPGlobalShortcutsEvent) => void) { + const lib = loadLibVesktop(); + if (!lib) return null; + + return new lib.XDPGlobalShortcuts(onEvent); +} + +export function openGnomeAppSettings() { + return loadLibVesktop()?.openGnomeAppSettings(APP_ID) ?? false; +} diff --git a/src/main/ipcSocket.ts b/src/main/ipcSocket.ts new file mode 100644 index 00000000..9a185c8a --- /dev/null +++ b/src/main/ipcSocket.ts @@ -0,0 +1,61 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import { rmSync } from "fs"; +import { createServer, Server } from "net"; +import { createInterface } from "readline"; + +import { app } from "electron"; +import { parseShortcutCommand } from "shared/utils/keybind"; + +import { SOCKET_PATH } from "./constants"; +import { runShortcutCommand } from "./keybinds"; + +let server: Server | undefined; + +function runCommand(line: string) { + const [command, arg = ""] = line.trim().split(/\s+/, 2); + + switch (command) { + case "run-shortcut": { + const shortcut = parseShortcutCommand(arg); + if (!shortcut) return "error: invalid shortcut"; + + runShortcutCommand(shortcut); + return "ok"; + } + default: + return "error: unknown command"; + } +} + +/** + * Line based socket for triggering actions from other programs, for example compositor keybinds. + * Connections stay open, so a client can send multiple commands, like `run-shortcut pushToTalk:down` and `:up`. + * Every line gets a reply line, either "ok" or "error: " + */ +export function initSocket() { + // We hold the single instance lock, so any existing socket is stale + if (process.platform !== "win32") rmSync(SOCKET_PATH, { force: true }); + + server = createServer(socket => { + socket.on("error", () => {}); + + createInterface({ input: socket }).on("line", line => { + if (line.trim()) socket.write(runCommand(line) + "\n"); + }); + }); + + server.on("error", err => console.error("Failed to start IPC socket:", err)); + server.listen(SOCKET_PATH); +} + +app.on("will-quit", () => { + if (!server) return; + + server.close(); + if (process.platform !== "win32") rmSync(SOCKET_PATH, { force: true }); +}); diff --git a/src/main/keybinds/actions.ts b/src/main/keybinds/actions.ts new file mode 100644 index 00000000..e378a431 --- /dev/null +++ b/src/main/keybinds/actions.ts @@ -0,0 +1,43 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import { IpcCommands } from "shared/IpcEvents"; +import { KeybindStatus, ShortcutAction } from "shared/utils/keybind"; + +import { IS_WAYLAND } from "../constants"; +import { AppEvents } from "../events"; +import { sendRendererCommand } from "../ipcCommands"; + +let appLoaded = false; +AppEvents.on("appLoaded", () => (appLoaded = true)); + +export let status: KeybindStatus = { backend: IS_WAYLAND ? "portal" : "hook" }; + +export function setStatus(newStatus: Omit) { + status = { backend: status.backend, ...newStatus }; + + if (appLoaded) + sendRendererCommand(IpcCommands.KEYBINDS_STATUS, status).catch(err => + console.error("Failed to send keybind status:", err) + ); +} + +// Events before Discord is loaded are dropped rather than queued, as they would all fire at once later +export function triggerAction(action: ShortcutAction, pressed: boolean) { + if (!appLoaded) return; + + sendRendererCommand(IpcCommands.KEYBINDS_TRIGGER, { action, pressed }).catch(err => + console.error("Failed to trigger keybind action:", action, err) + ); +} + +/** Runs a command parsed by parseShortcutCommand. If pressed is undefined, the action is pressed and released */ +export function runShortcutCommand({ action, pressed }: { action: ShortcutAction; pressed?: boolean }) { + if (pressed !== undefined) return triggerAction(action, pressed); + + triggerAction(action, true); + triggerAction(action, false); +} diff --git a/src/main/keybinds/hook.ts b/src/main/keybinds/hook.ts new file mode 100644 index 00000000..09e80cb3 --- /dev/null +++ b/src/main/keybinds/hook.ts @@ -0,0 +1,181 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import { systemPreferences } from "electron"; +import { KeyBind, KeybindStatus, ShortcutAction } from "shared/utils/keybind"; +import type { UiohookKeyboardEvent, UiohookMouseEvent } from "uiohook-napi"; + +import { triggerAction } from "./actions"; + +type Uiohook = typeof import("uiohook-napi"); +type InputEvent = UiohookKeyboardEvent | UiohookMouseEvent; +type ActiveBind = KeyBind & { action: ShortcutAction }; + +// uiohook key names that differ from our key names (KeyboardEvent.code with merged modifiers) +const KEY_RENAMES: Record = { + Ctrl: "Control", + CtrlRight: "Control", + AltRight: "Alt", + ShiftRight: "Shift", + MetaRight: "Meta", + // Numpad keys with NumLock off + NumpadInsert: "Numpad0", + NumpadEnd: "Numpad1", + NumpadArrowDown: "Numpad2", + NumpadPageDown: "Numpad3", + NumpadArrowLeft: "Numpad4", + NumpadArrowRight: "Numpad6", + NumpadHome: "Numpad7", + NumpadArrowUp: "Numpad8", + NumpadPageUp: "Numpad9", + NumpadDelete: "NumpadDecimal" +}; + +const MODIFIER_FLAGS = { + Control: "ctrlKey", + Shift: "shiftKey", + Alt: "altKey", + Meta: "metaKey" +} as const; + +let uiohook: Uiohook | null = null; +let keyNames = new Map(); +let running = false; + +let binds: ActiveBind[] = []; +const heldKeys = new Set(); +const activeBinds = new Set(); + +function toKeyName(uiohookName: string) { + if (/^[A-Z]$/.test(uiohookName)) return "Key" + uiohookName; + if (/^\d$/.test(uiohookName)) return "Digit" + uiohookName; + return KEY_RENAMES[uiohookName] ?? uiohookName; +} + +function loadUiohook() { + if (!uiohook) { + uiohook = require("uiohook-napi") as Uiohook; + keyNames = new Map(Object.entries(uiohook.UiohookKey).map(([name, code]) => [code, toKeyName(name)])); + } + + return uiohook; +} + +function press(key: string) { + // Held keys repeat their keydown event + if (heldKeys.has(key)) return; + heldKeys.add(key); + + // Other keys may be held too, so push to talk keeps working while moving in a game + for (const bind of binds) { + if (!activeBinds.has(bind) && bind.keys.includes(key) && bind.keys.every(k => heldKeys.has(k))) { + activeBinds.add(bind); + triggerAction(bind.action, true); + } + } +} + +function release(key: string) { + heldKeys.delete(key); + + for (const bind of activeBinds) { + if (bind.keys.includes(key)) { + activeBinds.delete(bind); + triggerAction(bind.action, false); + } + } +} + +function releaseAll() { + for (const key of heldKeys) release(key); +} + +// A modifier release can be missed, for example when the lock screen grabs input. The flags of later events tell us +function syncModifiers(event: InputEvent, key?: string) { + for (const [modifier, flag] of Object.entries(MODIFIER_FLAGS)) { + if (modifier !== key && heldKeys.has(modifier) && !event[flag]) release(modifier); + } +} + +function onKeyDown(event: UiohookKeyboardEvent) { + const key = keyNames.get(event.keycode); + syncModifiers(event, key); + if (key) press(key); +} + +function onKeyUp(event: UiohookKeyboardEvent) { + const key = keyNames.get(event.keycode); + syncModifiers(event, key); + if (key) release(key); +} + +// 1 and 2 are left and right click, which we don't allow binding +const mouseKey = (event: UiohookMouseEvent) => { + const button = event.button as number; + return button >= 3 && button <= 5 ? `Mouse${button}` : null; +}; + +function onMouseDown(event: UiohookMouseEvent) { + syncModifiers(event); + const key = mouseKey(event); + if (key) press(key); +} + +function onMouseUp(event: UiohookMouseEvent) { + syncModifiers(event); + const key = mouseKey(event); + if (key) release(key); +} + +function start() { + const { uIOhook } = loadUiohook(); + if (running) return; + + uIOhook.on("keydown", onKeyDown); + uIOhook.on("keyup", onKeyUp); + uIOhook.on("mousedown", onMouseDown); + uIOhook.on("mouseup", onMouseUp); + try { + uIOhook.start(); + } catch (err) { + uIOhook.removeAllListeners(); + throw err; + } + running = true; +} + +export function stopHook() { + releaseAll(); + if (!running) return; + + uiohook!.uIOhook.stop(); + uiohook!.uIOhook.removeAllListeners(); + running = false; +} + +/** Listens for the given binds, only running the input hook while there are any */ +export function setHookBinds(newBinds: KeyBind[]): Omit { + releaseAll(); + binds = newBinds.filter((b): b is ActiveBind => b.enabled && b.action !== "unassigned" && b.keys.length > 0); + + if (!binds.length) { + stopHook(); + return {}; + } + + if (process.platform === "darwin" && !systemPreferences.isTrustedAccessibilityClient(false)) { + stopHook(); + return { needsPermission: true }; + } + + try { + start(); + return {}; + } catch (err) { + console.error("Failed to start input hook:", err); + return { error: `Failed to listen to input: ${err instanceof Error ? err.message : err}` }; + } +} diff --git a/src/main/keybinds/index.ts b/src/main/keybinds/index.ts new file mode 100644 index 00000000..ff179c80 --- /dev/null +++ b/src/main/keybinds/index.ts @@ -0,0 +1,49 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import { app, systemPreferences } from "electron"; +import { IpcEvents } from "shared/IpcEvents"; + +import { IS_WAYLAND, SOCKET_PATH } from "../constants"; +import { Settings } from "../settings"; +import { handle, handleSync } from "../utils/ipcWrappers"; +import { setStatus, status } from "./actions"; +import { setHookBinds, stopHook } from "./hook"; +import { configurePortalShortcuts, setPortalEnabled, stopPortal } from "./portal"; + +export { runShortcutCommand } from "./actions"; + +// Wayland doesn't let apps see global input, not even XWayland ones, so we have to go through the portal there +function update() { + if (IS_WAYLAND) setPortalEnabled(!!Settings.store.globalShortcutsPortal); + else setStatus(setHookBinds(Settings.store.keyBinds ?? [])); +} + +export function initKeybinds() { + update(); + + if (IS_WAYLAND) Settings.addChangeListener("globalShortcutsPortal", update); + else Settings.addChangeListener("keyBinds", update); + + // macOS doesn't tell us when the permission is granted, so check again when the user comes back from System Settings + if (process.platform === "darwin") + app.on("browser-window-focus", () => { + if (status.needsPermission && systemPreferences.isTrustedAccessibilityClient(false)) update(); + }); +} + +handle(IpcEvents.KEYBINDS_GET_STATUS, () => status); +handleSync(IpcEvents.KEYBINDS_GET_SOCKET_PATH, () => SOCKET_PATH); +handle(IpcEvents.KEYBINDS_RETRY, update); +handle(IpcEvents.KEYBINDS_REQUEST_PERMISSION, () => { + if (process.platform === "darwin") systemPreferences.isTrustedAccessibilityClient(true); +}); +handle(IpcEvents.KEYBINDS_CONFIGURE_PORTAL, configurePortalShortcuts); + +app.on("will-quit", () => { + stopHook(); + stopPortal(); +}); diff --git a/src/main/keybinds/portal.ts b/src/main/keybinds/portal.ts new file mode 100644 index 00000000..e4c8ab03 --- /dev/null +++ b/src/main/keybinds/portal.ts @@ -0,0 +1,85 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import type { XDPGlobalShortcuts, XDPGlobalShortcutsEvent } from "libvesktop"; +import { ACTION_DESCRIPTIONS, isShortcutAction, SHORTCUT_ACTIONS } from "shared/utils/keybind"; + +import { createXDPGlobalShortcuts, openGnomeAppSettings } from "../dbus"; +import { setStatus, status, triggerAction } from "./actions"; + +let session: XDPGlobalShortcuts | null = null; + +function onEvent(...event: XDPGlobalShortcutsEvent) { + switch (event[0]) { + case "version": + setStatus({ ...status, portalVersion: event[1], portalConfigurable: canConfigure(event[1]) }); + break; + case "ready": + // The portal decides the triggers, so we register every action and let the user assign the ones they want + session?.bindShortcuts(SHORTCUT_ACTIONS.map(id => ({ id, description: ACTION_DESCRIPTIONS[id] }))); + setStatus({ ...status, portalState: "ready" }); + break; + case "shortcuts": { + // Portals only return shortcuts that have a trigger assigned + const triggers = new Map(event[1].map(s => [s.id, s.trigger])); + const portalShortcuts = SHORTCUT_ACTIONS.map(id => ({ + id, + description: ACTION_DESCRIPTIONS[id], + trigger: triggers.get(id) ?? "" + })); + setStatus({ ...status, portalShortcuts, error: undefined }); + break; + } + case "shortcut": + if (isShortcutAction(event[1])) triggerAction(event[1], event[2]); + break; + case "error": + console.error("GlobalShortcuts portal error:", event[1]); + setStatus({ ...status, error: event[1] }); + break; + case "fatal": + console.error("GlobalShortcuts portal is unavailable:", event[1]); + stopPortal(); + setStatus({ ...status, portalState: "unavailable", error: event[1] }); + break; + } +} + +export function stopPortal() { + session?.destroy(); + session = null; +} + +export function setPortalEnabled(enabled: boolean) { + if (!enabled) { + stopPortal(); + setStatus({ portalState: "disabled" }); + return; + } + + if (session) return; + + setStatus({ portalState: "connecting" }); + try { + session = createXDPGlobalShortcuts(onEvent); + if (!session) setStatus({ portalState: "unavailable", error: "Failed to load libvesktop" }); + } catch (err) { + console.error("Failed to create GlobalShortcuts portal session:", err); + setStatus({ portalState: "unavailable", error: String(err) }); + } +} + +const IS_GNOME = process.env.XDG_CURRENT_DESKTOP?.split(":").includes("GNOME") ?? false; + +// Portals before version 2 can't open their shortcut settings, but GNOME Settings has them on the app's page +const canConfigure = (version = 0) => version >= 2 || IS_GNOME; + +export function configurePortalShortcuts() { + if ((status.portalVersion ?? 0) >= 2) return session?.configureShortcuts(); + + if (IS_GNOME && !openGnomeAppSettings()) + setStatus({ ...status, error: "Failed to open GNOME Settings. Find Vesktop under Apps instead" }); +} diff --git a/src/main/main.ts b/src/main/main.ts index 3ede79b2..ebb386bd 100644 --- a/src/main/main.ts +++ b/src/main/main.ts @@ -11,9 +11,14 @@ import "./rpc"; import "./userAssets"; import "./vesktopProtocol"; import { app, BrowserWindow, nativeTheme } from "electron"; +import { parseShortcutCommand } from "shared/utils/keybind"; +// eslint-disable-next-line no-duplicate-imports +import { CommandLine } from "./cli"; import { DATA_DIR } from "./constants"; import { createFirstLaunchTour } from "./firstLaunch"; +import { initSocket } from "./ipcSocket"; +import { initKeybinds, runShortcutCommand } from "./keybinds"; import { createWindows, mainWin, openDeepLink } from "./mainWindow"; import { registerMediaPermissionsHandler } from "./mediaPermissions"; import { registerScreenShareHandler } from "./screenShare"; @@ -97,6 +102,12 @@ function init() { if (isDeckGameMode) nativeTheme.themeSource = "dark"; app.on("second-instance", (_event, cmdLine, _cwd, data: any) => { + if (data?.runShortcut) { + const command = parseShortcutCommand(data.runShortcut); + if (command) runShortcutCommand(command); + return; + } + if (data?.IS_DEV) return app.quit(); if (!mainWin) return; @@ -111,6 +122,8 @@ function init() { registerScreenShareHandler(); registerMediaPermissionsHandler(); + initKeybinds(); + initSocket(); bootstrap(); @@ -120,14 +133,19 @@ function init() { }); } -if (!app.requestSingleInstanceLock({ IS_DEV })) { - if (IS_DEV) { +const runShortcut = CommandLine.values["run-shortcut"]; + +if (!app.requestSingleInstanceLock({ IS_DEV, runShortcut })) { + if (IS_DEV && !runShortcut) { console.log("Vesktop is already running. Quitting previous instance..."); init(); } else { console.log("Vesktop is already running. Quitting..."); app.quit(); } +} else if (runShortcut) { + console.error("Vesktop is not running, so --run-shortcut has no effect"); + app.exit(1); } else { init(); } diff --git a/src/main/screenShare.ts b/src/main/screenShare.ts index 3459bc94..4a53a050 100644 --- a/src/main/screenShare.ts +++ b/src/main/screenShare.ts @@ -10,13 +10,11 @@ import { desktopCapturer, session, Streams } from "electron"; import type { StreamPick } from "renderer/components/ScreenSharePicker"; import { IpcCommands, IpcEvents } from "shared/IpcEvents"; +import { IS_WAYLAND } from "./constants"; import { sendRendererCommand } from "./ipcCommands"; import { handle } from "./utils/ipcWrappers"; import { isDiscordUrl } from "./utils/isDiscordUrl"; -const isWayland = - process.platform === "linux" && (process.env.XDG_SESSION_TYPE === "wayland" || !!process.env.WAYLAND_DISPLAY); - const supportsLoopbackWithoutChrome = process.platform === "win32" && Number(release().split(".").pop()) >= 19045; // Sources shown in the currently open picker. Only serve thumbnails for these, @@ -42,7 +40,7 @@ export function registerScreenShareHandler() { if (!isDiscordUrl(request.frame?.top?.url)) return callback(null); // request full resolution on wayland right away because we always only end up with one result anyway - const width = isWayland ? 1920 : 176; + const width = IS_WAYLAND ? 1920 : 176; const sources = await desktopCapturer .getSources({ types: ["window", "screen"], @@ -61,7 +59,7 @@ export function registerScreenShareHandler() { url: thumbnail.toDataURL() })); - if (isWayland) { + if (IS_WAYLAND) { const video = data[0]; if (video) { const stream = await sendRendererCommand(IpcCommands.SCREEN_SHARE_PICKER, { diff --git a/src/preload/VesktopNative.ts b/src/preload/VesktopNative.ts index 2c8ece10..a1bbaa80 100644 --- a/src/preload/VesktopNative.ts +++ b/src/preload/VesktopNative.ts @@ -8,6 +8,7 @@ import type { Node } from "@vencord/venmic"; import { ipcRenderer } from "electron/renderer"; import type { IpcMessage, IpcResponse } from "main/ipcCommands"; import type { Settings } from "shared/settings"; +import type { KeybindStatus } from "shared/utils/keybind"; import { IpcEvents } from "../shared/IpcEvents"; import { invoke, sendSync } from "./typedIpc"; @@ -95,6 +96,13 @@ export const VesktopNative = { unmute: () => invoke(IpcEvents.VIRT_MIC_UNMUTE), stop: () => invoke(IpcEvents.VIRT_MIC_STOP) }, + keybinds: { + getStatus: () => invoke(IpcEvents.KEYBINDS_GET_STATUS), + getSocketPath: () => sendSync(IpcEvents.KEYBINDS_GET_SOCKET_PATH), + retry: () => invoke(IpcEvents.KEYBINDS_RETRY), + requestPermission: () => invoke(IpcEvents.KEYBINDS_REQUEST_PERMISSION), + configurePortal: () => invoke(IpcEvents.KEYBINDS_CONFIGURE_PORTAL) + }, clipboard: { copyImage: (imageBuffer: Uint8Array, imageSrc: string) => invoke(IpcEvents.CLIPBOARD_COPY_IMAGE, imageBuffer, imageSrc) diff --git a/src/renderer/components/settings/Settings.tsx b/src/renderer/components/settings/Settings.tsx index 77cda0e8..d32e7383 100644 --- a/src/renderer/components/settings/Settings.tsx +++ b/src/renderer/components/settings/Settings.tsx @@ -9,6 +9,7 @@ import { classNameFactory } from "@vencord/types/api/Styles"; import { Divider, ErrorBoundary, Text } from "@vencord/types/components"; import { ComponentType } from "react"; import { WebRTCIPHandlingPolicyPicker } from "renderer/components/settings/WebRTCIPHandlingPolicyPicker"; +import { KeybindsButton } from "renderer/globalShortcuts/ShortcutSettings"; import { getValueAndOnChange, Settings, useSettings } from "renderer/settings"; import { isMac } from "renderer/utils"; @@ -128,7 +129,8 @@ const SettingsOptions: Record> key: "disableSmoothScroll", title: "Disable smooth scrolling", description: "Disables smooth scrolling" - } + }, + KeybindsButton ], Notifications: [ NotificationBadgeToggle, diff --git a/src/renderer/globalShortcuts/ShortcutSettings.css b/src/renderer/globalShortcuts/ShortcutSettings.css new file mode 100644 index 00000000..2ae483d3 --- /dev/null +++ b/src/renderer/globalShortcuts/ShortcutSettings.css @@ -0,0 +1,92 @@ +.vcd-shortcuts-container { + display: flex; + flex-direction: column; + gap: 1em; + padding-block: 1em; +} + +.vcd-shortcuts-card, +.vcd-shortcuts-buttons { + display: flex; + gap: 0.5em; +} + +.vcd-shortcuts-card { + flex-direction: column; + align-items: start; +} + +.vcd-shortcuts-row { + display: grid; + grid-template-columns: minmax(0, 1fr) minmax(0, 1fr) auto auto; + gap: 0.5em; + align-items: center; +} + +.vcd-shortcuts-recorder { + display: flex; + align-items: center; + gap: 0.5em; + background-color: var(--input-background-default); + border: 1px solid var(--input-border-default); + border-radius: var(--radius-sm); + min-height: calc(var(--select-option-height) - 2px); + padding: 3px 4px 3px 12px; + box-sizing: border-box; +} + +.vcd-shortcuts-recorder-keys { + flex: 1; + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.vcd-shortcuts-muted { + color: var(--text-muted); +} + +.vcd-shortcuts-table { + width: 100%; + border-collapse: collapse; + border: 1px solid var(--border-subtle); + border-radius: var(--radius-sm); + + & th, + & td { + text-align: start; + padding: 0.6em 1em; + border-bottom: 1px solid var(--border-subtle); + } + + & th { + text-transform: uppercase; + background-color: var(--background-base-lower); + } + + & tr:last-child td { + border-bottom: none; + } +} + +.vcd-shortcuts-external { + display: flex; + flex-direction: column; + gap: 1.25em; + + & :is(h3, h4) { + margin: 0; + } +} + +.vcd-shortcuts-external-section { + display: flex; + flex-direction: column; + gap: 0.5em; + + & pre { + max-width: none; + margin: 0; + } +} diff --git a/src/renderer/globalShortcuts/ShortcutSettings.tsx b/src/renderer/globalShortcuts/ShortcutSettings.tsx new file mode 100644 index 00000000..15b24200 --- /dev/null +++ b/src/renderer/globalShortcuts/ShortcutSettings.tsx @@ -0,0 +1,340 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import "./ShortcutSettings.css"; +import { + Button, + Card, + CodeBlock, + DeleteIcon, + Divider, + FormSwitch, + HeadingSecondary, + HeadingTertiary, + InlineCode, + Paragraph, + Switch, + Text +} from "@vencord/types/components"; +import { classNameFactory, identity } from "@vencord/types/utils"; +import { Modal, openModal, React, Select, useEffect, useState } from "@vencord/types/webpack/common"; +import { SettingsComponent } from "renderer/components/settings/Settings"; +import { onIpcCommand } from "renderer/ipcCommands"; +import { reactiveValue } from "renderer/reactiveState"; +import { useSettings } from "renderer/settings"; +import { isLinux } from "renderer/utils"; +import { IpcCommands } from "shared/IpcEvents"; +import { ACTION_DESCRIPTIONS, KeyBind, KeybindStatus } from "shared/utils/keybind"; + +import { keysToDisplay, loadKeyboardLayout, recordKeybind } from "./recordKeybind"; + +const cl = classNameFactory("vcd-shortcuts-"); + +const keybindStatus = reactiveValue(null); +onIpcCommand(IpcCommands.KEYBINDS_STATUS, (status: KeybindStatus) => (keybindStatus.value = status)); + +const ACTION_OPTIONS = [ + { label: "Unassigned", value: "unassigned" }, + ...Object.entries(ACTION_DESCRIPTIONS).map(([value, label]) => ({ label, value })) +]; + +function ErrorCard({ children, onRetry }: { children: React.ReactNode; onRetry?(): void }) { + return ( + + {children} + {onRetry && ( + + )} + + ); +} + +function KeybindRecorder({ + keybind: { keys, labels }, + onChange +}: { + keybind: KeyBind; + onChange(recorded: Pick): void; +}) { + const [controller, setController] = useState(null); + + // Stop listening for input if the modal is closed while recording + useEffect(() => () => controller?.abort(), [controller]); + + async function toggleRecording() { + if (controller) return controller.abort(); + + const newController = new AbortController(); + setController(newController); + try { + onChange(await recordKeybind(newController.signal)); + } catch { + // aborted + } finally { + setController(null); + } + } + + const display = keys.length ? keysToDisplay(keys, labels) : "No Keybind Set"; + + return ( +
+ + {controller ? "Press keys or mouse buttons..." : display} + + +
+ ); +} + +function KeybindRow({ + keybind, + onChange, + onDelete +}: { + keybind: KeyBind; + onChange(keybind: KeyBind): void; + onDelete(): void; +}) { + return ( +
+