Method build_command

src/crates/services/services-core/src/lsp/process.rs:880–1071

Builds the command based on the runtime type.

(
        runtime_type: &RuntimeType,
        server_bin: &PathBuf,
        config: &ServerConfig,
    )

    /// Builds the command based on the runtime type.
    fn build_command(
        runtime_type: &RuntimeType,
        server_bin: &PathBuf,
        config: &ServerConfig,
    ) -> Result<tokio::process::Command> {
        match runtime_type {
            RuntimeType::Executable => {
                #[cfg(windows)]
                {
                    if let Some(ext) = server_bin.extension().and_then(|e| e.to_str()) {
                        let ext_lower = ext.to_lowercase();

                        if ext_lower == "bat" || ext_lower == "cmd" {
                            debug!(
                                "Detected batch file (.{}), extracting node command",
                                ext_lower
                            );

                            if let Ok(content) = std::fs::read_to_string(server_bin) {
                                let mut script_path: Option<PathBuf> = None;

                                for line in content.lines() {
                                    let line = line.trim();

                                    if line.starts_with("node ") || line.starts_with("node.exe ") {
                                        info!("Found node execution command: {}", line);

                                        if let Some(start_quote) = line.find('"') {
                                            if let Some(end_quote) =
                                                line[start_quote + 1..].find('"')
                                            {
                                                let path_expr = &line
                                                    [start_quote + 1..start_quote + 1 + end_quote];
                                                debug!("Extracted path expression: {}", path_expr);

                                                for prev_line in content.lines() {
                                                    let prev_line = prev_line.trim();
                                                    if prev_line.starts_with("set ")
                                                        && prev_line.contains(
                                                            path_expr
                                                                .trim_matches('%')
                                                                .split('%')
                                                                .next()
                                                                .unwrap_or(""),
                                                        )
                                                    {
                                                        if let Some(eq_pos) = prev_line.find('=') {
                                                            let value_part = &prev_line
                                                                [eq_pos + 1..]
                                                                .trim_matches('"');

                                                            if let Some(parent) =
                                                                server_bin.parent()
                                                            {
                                                                let mut resolved_path =
                                                                    parent.to_path_buf();

                                                                let rel_part = value_part