feat(lsp): patch root fields in initialize request

- Add ensure_root to patch rootUri, rootPath, and workspaceFolders in LSP initialize
- Remove wine pre-build and runner from Cross.toml for Windows target
- Refactor PID patching logic to run after ensure_root in proxy/io.rs
- Update tests to cover ensure_root behavior

Author: richardhapb

Cross.toml

@@ -3,9 +3,3 @@ image = "ghcr.io/cross-rs/x86_64-unknown-linux-gnu:latest"
 
 [target.x86_64-pc-windows-gnu]
 image = "ghcr.io/cross-rs/x86_64-pc-windows-gnu:latest"
-pre-build = [
-    "dpkg --add-architecture i386",
-    "apt-get update", 
-    "apt-get install -y wine wine64"
-]
-runner = "wine64"

src/lsp/binding.rs

@@ -301,6 +301,63 @@ pub fn encode_path(msg: &Bytes, config: &mut ProxyConfig) {
     }
 }
 
+pub fn ensure_root(msg: &mut Bytes, config: &ProxyConfig) {
+    let docker_uri = format!("file://{}", config.docker_internal_path);
+
+    // Patch rootUri
+    let key = b"\"rootUri\":\"";
+    if let Some(mut beg) = find(msg, key) {
+        beg += key.len();
+        if let Some(mut end) = find(&msg[beg..], b"\"") {
+            end += beg; // Make it absolute position
+            let before = &msg[..beg];
+            let after = &msg[end..];
+            *msg = Bytes::from([before, docker_uri.as_bytes(), after].concat());
+        }
+    }
+
+    // Patch rootPath if present
+    let key = b"\"rootPath\":\"";
+    if let Some(mut beg) = find(msg, key) {
+        beg += key.len();
+        if let Some(mut end) = find(&msg[beg..], b"\"") {
+            end += beg;
+            let before = &msg[..beg];
+            let after = &msg[end..];
+            *msg = Bytes::from([before, docker_uri.as_bytes(), after].concat());
+        }
+    }
+
+    let key = b"\"workspaceFolders\":[";
+    if let Some(mut beg) = find(msg, key) {
+        beg += key.len();
+        if let Some(mut end) = find(&msg[beg..], b"]") {
+            end += beg;
+            let before = &msg[..beg];
+            let after = &msg[end..];
+            if let Some(ws) = patch_workspace_folders(&msg[beg..end], &docker_uri) {
+                *msg = Bytes::from([before, &ws, after].concat());
+            }
+        }
+    }
+}
+
+fn patch_workspace_folders(msg: &[u8], docker_uri: &str) -> Option<Bytes> {
+    let key = b"\"uri\":\"";
+    let mut result = None;
+    for uri_beg in find_iter(msg, key) {
+        let beg = uri_beg + key.len();
+        if let Some(mut end) = find(&msg[beg..], b"\"") {
+            end += beg;
+            let before = &msg[..beg];
+            let after = &msg[end..];
+            result = Some(Bytes::from([before, docker_uri.as_bytes(), after].concat()));
+        }
+    }
+
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -365,6 +422,25 @@ mod tests {
             lspbody!(&expected => "bytes")
         );
     }
+
+    #[test]
+    fn ensure_root_patches_correctly() {
+        let mut config = construct_config();
+        config.local_path = "/test/path/app".to_string();
+
+        let msg = lspmsg!(
+            "method": "initialize",
+            "rootUri": "file:///test/path",
+            "rootPath": "/test/path"
+        );
+
+        let mut request = Bytes::from(msg);
+        ensure_root(&mut request, &config);
+
+        let body = lspbody!(&request => "string");
+        assert!(find(body, b"\"rootUri\":\"file:///usr/home/app\"").is_some());
+        assert!(find(body, b"\"rootPath\":\"file:///usr/home/app\"").is_some());
+    }
 }
 
 #[cfg(test)]

src/lsp/pid.rs

@@ -1,4 +1,3 @@
-use memchr::memmem::find;
 use serde_json::{Value, json};
 use tokio_util::bytes::Bytes;
 use tracing::{debug, trace};
@@ -21,12 +20,7 @@ impl PidHandler {
     pub fn try_take_initialize_process_id(
         &mut self,
         raw_bytes: &mut Bytes,
-    ) -> serde_json::error::Result<bool> {
-        if find(raw_bytes, br#""method":"initialize""#).is_none() {
-            trace!("Initialize method not found, skipping patch");
-            return Ok(false);
-        }
-
+    ) -> serde_json::error::Result<()> {
         debug!("Initialize method found, patching");
         trace!(?raw_bytes, "before patch");
 
@@ -42,6 +36,6 @@ impl PidHandler {
             trace!(?raw_bytes, "patched");
         }
 
-        Ok(true)
+        Ok(())
     }
 }

src/proxy/io.rs

@@ -1,8 +1,9 @@
+use memchr::memmem::find;
 use std::time::Duration;
 use tokio_util::sync::CancellationToken;
 
 use crate::lsp::{
-    binding::{RequestTracker, redirect_uri},
+    binding::{RequestTracker, ensure_root, redirect_uri},
     parser::{LspFramedReader, send_message},
     pid::PidHandler,
 };
@@ -109,7 +110,7 @@ where
         async move {
             let mut reader = LspFramedReader::new(reader);
             let mut empty_counter = 0;
-            let mut pid_patched = false;
+            let mut lsp_initialized = false;
             // The PID patch is required only on the client side for the `initialize` method.
             let mut pid_handler: Option<PidHandler> = match pair {
                 Pair::Server => None,
@@ -137,15 +138,14 @@ where
                                 }
 
                                 for mut msg in msgs {
-                                    if config_clone.requires_patch_pid() &&
-                                    !pid_patched &&
-                                    let Some(ref mut pid_handler_ref) = pid_handler {
-                                        trace!("Trying to take the PID from the initialize method");
+                                    if config_clone.use_docker {
+                                        if !lsp_initialized && find(&msg, br#""method":"initialize""#).is_some() {
+                                            lsp_initialized = true;
+
+                                            ensure_root(&mut msg, &config_clone);
 
-                                        // The function returns true if the take succeeds
-                                        pid_patched = pid_handler_ref.try_take_initialize_process_id(&mut msg)?;
+                                            trace!("Initialize method found");
 
-                                        if pid_patched {
                                             // If it is in initialize method, capture the
                                             // colon encoding in Windows
                                             #[cfg(windows)]
@@ -154,14 +154,20 @@ where
                                                 use crate::lsp::binding::encode_path;
                                                 encode_path(&msg, &mut config_clone);
                                             }
-                                        }
-                                    }
 
-                                    if config_clone.use_docker {
+                                            if config_clone.requires_patch_pid() &&
+                                            let Some(ref mut pid_handler_ref) = pid_handler {
+                                                trace!("Trying to take the PID from the initialize method");
+
+                                                // The function returns true if the take succeeds
+                                                pid_handler_ref.try_take_initialize_process_id(&mut msg)?;
+                                            }
+                                        }
 
                                         redirect_uri(&mut msg, &pair, &config_clone)?;
                                         tracker_inner.check_for_methods(GOTO_METHODS, &mut msg, &pair).await?;
                                     }
+
                                     send_message(&mut writer, &msg).await.map_err(|e| {
                                         error!("Failed to forward the request: {}", e);
                                         e