fix: more stolen code

- replace flatpak-builder run with flatpak build
- fix env handling
- have every build dir be inside .flatplay
- once again, most of this is not mine

Author: mufeedali

Cargo.lock

@@ -16,6 +16,7 @@ colored = "3.0.0"
 walkdir = "2.5.0"
 console = "0.16.0"
 clap_complete = "4.5.55"
+regex = "1.11.1"
 
 [[bin]]
 name = "flatplay"

Cargo.toml

@@ -24,20 +24,20 @@ fn command_succeeds(cmd: &str, args: &[&str]) -> bool {
 
 // Runs a command, handling Flatpak sandbox and container specifics.
 pub fn run_command(command: &str, args: &[&str]) -> Result<()> {
-    let mut args = args.to_vec();
+    let mut command_args = args.to_vec();
 
     // Workaround for rofiles-fuse issues in containers.
     if command == "flatpak-builder"
         && is_inside_container()
-        && !args.contains(&"--disable-rofiles-fuse")
+        && !command_args.contains(&"--disable-rofiles-fuse")
     {
-        args.push("--disable-rofiles-fuse");
+        command_args.push("--disable-rofiles-fuse");
     }
 
-    let (program, args) = if is_sandboxed() {
+    let (program, final_args) = if is_sandboxed() {
         if command_succeeds("host-spawn", &["--version"]) {
             let mut new_args = vec![command];
-            new_args.extend_from_slice(&args);
+            new_args.extend_from_slice(&command_args);
             ("host-spawn", new_args)
         } else {
             let mut new_args = vec![
@@ -46,26 +46,26 @@ pub fn run_command(command: &str, args: &[&str]) -> Result<()> {
                 "--env=TERM=xterm-256color",
                 command,
             ];
-            new_args.extend_from_slice(&args);
+            new_args.extend_from_slice(&command_args);
             ("flatpak-spawn", new_args)
         }
     } else {
-        (command, args)
+        (command, command_args)
     };
 
     println!(
         "\n{} {} {}",
         ">".purple().bold(),
         program.italic(),
-        args.join(" ").italic()
+        final_args.join(" ").italic()
     );
-    let mut command = Command::new(program)
-        .args(&args)
+    let mut command_process = Command::new(program)
+        .args(&final_args)
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
         .spawn()?;
 
-    let status = command.wait()?;
+    let status = command_process.wait()?;
 
     if !status.success() {
         return Err(anyhow::anyhow!(

src/command.rs

@@ -1,6 +1,7 @@
 pub mod command;
 pub mod manifest;
 pub mod state;
+pub mod utils;
 
 use anyhow::Result;
 use colored::*;
@@ -10,6 +11,7 @@ use dialoguer::{Select, theme::ColorfulTheme};
 use manifest::Manifest;
 use state::State;
 use std::fs;
+use utils::{get_a11y_bus_args, get_host_env};
 use walkdir::WalkDir;
 
 const BUILD_DIR: &str = ".flatplay";
@@ -138,36 +140,49 @@ impl FlatpakManager {
                     let buildsystem = buildsystem.as_deref();
                     match buildsystem {
                         Some("meson") => {
+                            let build_dir = format!("{}/_build", BUILD_DIR);
                             let mut meson_args = vec!["build", &repo_dir, "meson", "setup"];
                             if let Some(config_opts) = config_opts {
                                 meson_args.extend(config_opts.iter().map(|s| s.as_str()));
                             }
-                            meson_args.extend(&["--prefix=/app", "_build"]);
+                            meson_args.extend(&["--prefix=/app", &build_dir]);
                             run_command("flatpak", &meson_args)?;
-                            run_command("flatpak", &["build", &repo_dir, "ninja", "-C", "_build"])?;
                             run_command(
                                 "flatpak",
-                                &["build", &repo_dir, "meson", "install", "-C", "_build"],
+                                &["build", &repo_dir, "ninja", "-C", &build_dir],
+                            )?;
+                            run_command(
+                                "flatpak",
+                                &["build", &repo_dir, "meson", "install", "-C", &build_dir],
                             )?;
                         }
                         Some("cmake") | Some("cmake-ninja") => {
+                            let build_dir = format!("{}/_build", BUILD_DIR);
+                            let b_flag = format!("-B{}", build_dir);
                             let mut cmake_args = vec![
                                 "build",
                                 &repo_dir,
                                 "cmake",
                                 "-G",
                                 "Ninja",
-                                "..",
-                                ".",
+                                &b_flag,
+                                "-DCMAKE_EXPORT_COMPILE_COMMANDS=1",
+                                "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
                                 "-DCMAKE_INSTALL_PREFIX=/app",
                             ];
                             if let Some(config_opts) = config_opts {
                                 cmake_args.extend(config_opts.iter().map(|s| s.as_str()));
                             }
-                            run_command("mkdir", &["-p", &format!("{}/_build", BUILD_DIR)])?;
+                            cmake_args.push(".");
                             run_command("flatpak", &cmake_args)?;
-                            run_command("flatpak", &["build", &repo_dir, "ninja"])?;
-                            run_command("flatpak", &["build", &repo_dir, "ninja", "install"])?;
+                            run_command(
+                                "flatpak",
+                                &["build", &repo_dir, "ninja", "-C", &build_dir],
+                            )?;
+                            run_command(
+                                "flatpak",
+                                &["build", &repo_dir, "ninja", "-C", &build_dir, "install"],
+                            )?;
                         }
                         Some("simple") => {
                             if let Some(build_commands) = build_commands {
@@ -333,17 +348,38 @@ impl FlatpakManager {
         }
 
         let manifest = self.manifest.as_ref().unwrap();
-        let manifest_path = self.state.active_manifest.as_ref().unwrap();
         let repo_dir = format!("{}/repo", BUILD_DIR);
 
-        let args = vec![
-            "--run",
-            &repo_dir,
-            manifest_path.to_str().unwrap(),
-            &manifest.command,
+        let mut args = vec![
+            "build".to_string(),
+            "--with-appdir".to_string(),
+            "--allow=devel".to_string(),
+            "--talk-name=org.freedesktop.portal.*".to_string(),
+            "--talk-name=org.a11y.Bus".to_string(),
         ];
 
-        flatpak_builder(&args)
+        for (key, value) in get_host_env() {
+            args.push(format!("--env={}={}", key, value));
+        }
+
+        for arg in get_a11y_bus_args() {
+            args.push(arg);
+        }
+
+        for arg in &manifest.finish_args {
+            args.push(arg.clone());
+        }
+        args.push(repo_dir);
+        args.push(manifest.command.clone());
+        if let Some(x_run_args) = &manifest.x_run_args {
+            for arg in x_run_args {
+                args.push(arg.clone());
+            }
+        }
+
+        let args_str: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+
+        run_command("flatpak", &args_str)
     }
 
     pub fn clean(&mut self) -> Result<()> {

src/lib.rs

@@ -52,6 +52,8 @@ pub struct Manifest {
     #[serde(rename = "runtime-version")]
     pub runtime_version: String,
     pub command: String,
+    #[serde(rename = "x-run-args")]
+    pub x_run_args: Option<Vec<String>>,
     #[serde(default)]
     pub modules: Vec<Module>,
     #[serde(rename = "finish-args", default)]

src/manifest.rs

@@ -0,0 +1,73 @@
+use regex::Regex;
+use std::collections::HashMap;
+use std::env;
+use std::process::Command;
+
+pub fn get_host_env() -> HashMap<String, String> {
+    let forwarded_env_keys = vec![
+        "COLORTERM",
+        "DESKTOP_SESSION",
+        "LANG",
+        "WAYLAND_DISPLAY",
+        "XDG_CURRENT_DESKTOP",
+        "XDG_SEAT",
+        "XDG_SESSION_DESKTOP",
+        "XDG_SESSION_ID",
+        "XDG_SESSION_TYPE",
+        "XDG_VTNR",
+        "AT_SPI_BUS_ADDRESS",
+    ];
+
+    let mut env_vars = HashMap::new();
+
+    for (key, value) in env::vars() {
+        if forwarded_env_keys.contains(&key.as_str()) {
+            env_vars.insert(key, value);
+        }
+    }
+
+    env_vars
+}
+
+pub fn get_a11y_bus_args() -> Vec<String> {
+    let output = Command::new("gdbus")
+        .args([
+            "call",
+            "--session",
+            "--dest=org.a11y.Bus",
+            "--object-path=/org/a11y/bus",
+            "--method=org.a11y.Bus.GetAddress",
+        ])
+        .output();
+
+    let output = match output {
+        Ok(output) if output.status.success() => output,
+        _ => return Vec::new(),
+    };
+
+    let address = String::from_utf8_lossy(&output.stdout)
+        .trim()
+        .replace("('", "")
+        .replace("',)", "");
+
+    let re = Regex::new(r"unix:path=([^,]+)(,.*)?").unwrap();
+    let caps = match re.captures(&address) {
+        Some(caps) => caps,
+        None => return Vec::new(),
+    };
+
+    let unix_path = caps.get(1).map_or("", |m| m.as_str());
+    let suffix = caps.get(2).map_or("", |m| m.as_str());
+
+    vec![
+        format!("--bind-mount=/run/flatpak/at-spi-bus={}", unix_path),
+        if !suffix.is_empty() {
+            format!(
+                "--env=AT_SPI_BUS_ADDRESS=unix:path=/run/flatpak/at-spi-bus{}",
+                suffix
+            )
+        } else {
+            "--env=AT_SPI_BUS_ADDRESS=unix:path=/run/flatpak/at-spi-bus".to_string()
+        },
+    ]
+}