logiguard fork: GPUI xdg-activation keyboard-focus serial fix

Single-commit orphan branch: full zed-industries/zed @ 8c74db0 source tree
with a 3-file patch applied (no upstream history).

Patch (crates/gpui_linux/src/linux/wayland/):
  - serial.rs: add SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; add latest_serial_of()
  - window.rs: activate() uses keyboard-enter serial (Mutter focus gate)

Mutter honors window activation only when the token carries the keyboard-
focus serial from wl_keyboard.enter; GPUI used a stale mouse-press serial.
See docs/tray-window-focus-wayland.md in logiguard.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/remote_server/Cargo.toml

@@ -0,0 +1,115 @@
+[package]
+name = "remote_server"
+description = "Daemon used for remote editing"
+edition.workspace = true
+version = "0.1.0"
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/server.rs"
+doctest = false
+
+[[bin]]
+name = "remote_server"
+
+[features]
+default = []
+debug-embed = ["dep:rust-embed"]
+test-support = ["fs/test-support"]
+
+[dependencies]
+anyhow.workspace = true
+async-channel.workspace = true
+askpass.workspace = true
+clap.workspace = true
+client.workspace = true
+collections.workspace = true
+crashes.workspace = true
+dap_adapters.workspace = true
+debug_adapter_extension.workspace = true
+env_logger.workspace = true
+extension.workspace = true
+extension_host.workspace = true
+fs.workspace = true
+futures.workspace = true
+git.workspace = true
+git_hosting_providers.workspace = true
+git2 = { workspace = true, features = ["vendored-libgit2"] }
+gpui.workspace = true
+gpui_platform.workspace = true
+gpui_tokio.workspace = true
+http_client.workspace = true
+image.workspace = true
+json_schema_store.workspace = true
+language.workspace = true
+language_extension.workspace = true
+languages.workspace = true
+log.workspace = true
+lsp.workspace = true
+net.workspace = true
+node_runtime.workspace = true
+paths.workspace = true
+project.workspace = true
+proto.workspace = true
+release_channel.workspace = true
+remote.workspace = true
+reqwest_client.workspace = true
+rpc.workspace = true
+rust-embed = { workspace = true, optional = true, features = ["debug-embed"] }
+semver.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+shellexpand.workspace = true
+smol.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+util.workspace = true
+watch.workspace = true
+worktree.workspace = true
+thiserror.workspace = true
+rayon.workspace = true
+uuid = { workspace = true, features = ["v4"] }
+
+[target.'cfg(not(windows))'.dependencies]
+crash-handler.workspace = true
+fork.workspace = true
+libc.workspace = true
+minidumper.workspace = true
+
+[target.'cfg(windows)'.dependencies]
+windows.workspace = true
+gpui = { workspace = true, features = ["windows-manifest"] }
+
+[dev-dependencies]
+action_log.workspace = true
+agent = { workspace = true, features = ["test-support"] }
+client = { workspace = true, features = ["test-support"] }
+clock = { workspace = true, features = ["test-support"] }
+editor = { workspace = true, features = ["test-support"] }
+fs = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+http_client = { workspace = true, features = ["test-support"] }
+language = { workspace = true, features = ["test-support"] }
+node_runtime = { workspace = true, features = ["test-support"] }
+pretty_assertions.workspace = true
+project = { workspace = true, features = ["test-support"] }
+remote = { workspace = true, features = ["test-support"] }
+theme_settings.workspace = true
+theme = { workspace = true, features = ["test-support"] }
+language_model = { workspace = true, features = ["test-support"] }
+lsp = { workspace = true, features = ["test-support"] }
+unindent.workspace = true
+serde_json.workspace = true
+zlog.workspace = true
+
+[build-dependencies]
+cargo_toml.workspace = true
+toml.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["git2", "rust-embed", "paths"]

crates/remote_server/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/remote_server/build.rs

@@ -0,0 +1,34 @@
+#![allow(clippy::disallowed_methods, reason = "build scripts are exempt")]
+use std::process::Command;
+
+const ZED_MANIFEST: &str = include_str!("../zed/Cargo.toml");
+
+fn main() {
+    let zed_cargo_toml: cargo_toml::Manifest =
+        toml::from_str(ZED_MANIFEST).expect("failed to parse zed Cargo.toml");
+    println!(
+        "cargo:rustc-env=ZED_PKG_VERSION={}",
+        zed_cargo_toml.package.unwrap().version.unwrap()
+    );
+    println!(
+        "cargo:rustc-env=TARGET={}",
+        std::env::var("TARGET").unwrap()
+    );
+
+    // Populate git sha environment variable if git is available
+    println!("cargo:rerun-if-changed=../../.git/logs/HEAD");
+    if let Some(output) = Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+    {
+        let git_sha = String::from_utf8_lossy(&output.stdout);
+        let git_sha = git_sha.trim();
+
+        println!("cargo:rustc-env=ZED_COMMIT_SHA={git_sha}");
+    }
+    if let Some(build_identifier) = option_env!("GITHUB_RUN_NUMBER") {
+        println!("cargo:rustc-env=ZED_BUILD_ID={build_identifier}");
+    }
+}

crates/remote_server/src/main.rs

@@ -0,0 +1,63 @@
+use clap::Parser;
+use remote_server::Commands;
+use std::io::Write as _;
+use std::path::PathBuf;
+
+#[derive(Parser)]
+#[command(disable_version_flag = true)]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+    /// Used for SSH/Git password authentication, to remove the need for netcat as a dependency,
+    /// by having Zed act like netcat communicating over a Unix socket.
+    #[arg(long, hide = true)]
+    askpass: Option<String>,
+    /// Used for recording minidumps on crashes by having the server run a separate
+    /// process communicating over a socket.
+    #[arg(long, hide = true)]
+    crash_handler: Option<PathBuf>,
+    /// Used for loading the environment from the project.
+    #[arg(long, hide = true)]
+    printenv: bool,
+}
+
+fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+
+    if let Some(socket_path) = &cli.askpass {
+        askpass::main(socket_path);
+        return Ok(());
+    }
+
+    if let Some(socket) = &cli.crash_handler {
+        crashes::crash_server(socket.as_path(), paths::logs_dir().clone());
+        return Ok(());
+    }
+
+    if cli.printenv {
+        util::shell_env::print_env();
+        return Ok(());
+    }
+
+    if let Some(command) = cli.command {
+        use remote_server::ExecuteProxyError;
+
+        let res = remote_server::run(command);
+        if let Err(e) = &res
+            && let Some(e) = e.downcast_ref::<ExecuteProxyError>()
+        {
+            std::io::stderr().write_fmt(format_args!("{e:#}\n")).ok();
+            // It is important for us to report the proxy spawn exit code here
+            // instead of the generic 1 that result returns
+            // The client reads the exit code to determine if the server process has died when trying to reconnect
+            // signaling that it needs to try spawning a new server
+            std::process::exit(e.to_exit_code());
+        }
+        res
+    } else {
+        std::io::stderr()
+            .write_all(b"usage: remote <run|proxy|version>\n")
+            .ok();
+        std::process::exit(1);
+    }
+}

crates/remote_server/src/windows.rs

@@ -0,0 +1,48 @@
+use windows::Win32::System::Com::{
+    CLSCTX_LOCAL_SERVER, COINIT_APARTMENTTHREADED, CoCreateInstance, CoInitializeEx, IDispatch,
+    IServiceProvider,
+};
+use windows::Win32::System::Variant::VARIANT;
+use windows::Win32::UI::Shell::{
+    CSIDL_DESKTOP, IShellBrowser, IShellDispatch2, IShellFolderViewDual, IShellWindows,
+    SID_STopLevelBrowser, SVGIO_BACKGROUND, SWC_DESKTOP, SWFO_NEEDDISPATCH, ShellWindows,
+};
+use windows::core::{BSTR, Interface};
+
+pub fn shell_execute_from_explorer(
+    file: &str,
+    parameters: &str,
+    directory: &str,
+) -> anyhow::Result<()> {
+    unsafe {
+        CoInitializeEx(None, COINIT_APARTMENTTHREADED).unwrap();
+
+        let mut _hwnd = Default::default();
+        let shell_dispatch: IShellDispatch2 =
+            CoCreateInstance::<_, IShellWindows>(&ShellWindows, None, CLSCTX_LOCAL_SERVER)?
+                .FindWindowSW(
+                    &VARIANT::from(CSIDL_DESKTOP as i32),
+                    &VARIANT::default(),
+                    SWC_DESKTOP,
+                    &mut _hwnd,
+                    SWFO_NEEDDISPATCH,
+                )?
+                .cast::<IServiceProvider>()?
+                .QueryService::<IShellBrowser>(&SID_STopLevelBrowser)?
+                .QueryActiveShellView()?
+                .GetItemObject::<IDispatch>(SVGIO_BACKGROUND)?
+                .cast::<IShellFolderViewDual>()?
+                .Application()?
+                .cast()?;
+
+        shell_dispatch.ShellExecute(
+            &BSTR::from(file),
+            &VARIANT::from(parameters),
+            &VARIANT::from(directory),
+            &VARIANT::from(""),
+            &VARIANT::from(0i32),
+        )?;
+
+        Ok(())
+    }
+}