fix(build.mcpp): run with cwd = project root (capture_exec cwd param)

build.mcpp wrote its generated sources relative to the CHILD's cwd = mcpp's
invocation dir, which is the project root only by coincidence. Running it via
'mcpp test -p <member>' (or any invocation from another dir) wrote the files to
the wrong place -> 'declared generated source does not exist'.

Add an optional cwd to platform::process::capture_exec (Linux:
posix_spawn_file_actions_addchdir_np; else: 'cd <cwd> && ' prefix) and run/
compile build.mcpp with cwd = project root. Also unblocks the future typed
import-mcpp module (GCC gcm.cache staging needs a controllable cwd).

e2e 89 extended: build from a nested subdir, assert the generated source lands
in the project root.

Author: Sunrisepeak

src/build/build_program.cppm

@@ -299,15 +299,17 @@ std::expected<void, std::string> run_build_program(
     compileArgv.push_back(src.string());
     compileArgv.push_back("-o"); compileArgv.push_back(bin.string());
     mcpp::ui::info("build.mcpp", "compiling");
-    auto cres = mcpp::platform::process::capture_exec(compileArgv);
+    auto cres = mcpp::platform::process::capture_exec(compileArgv, {}, root.string());
     if (cres.exit_code != 0) {
         return std::unexpected(std::format(
             "build.mcpp failed to compile (exit {}):\n{}", cres.exit_code, cres.output));
     }
 
     // ── Run it; capture stdout(+stderr) and parse directives ────────────────
+    // Run with cwd = project root so the program's relative file writes (e.g.
+    // mcpp:generated sources) land in the project, not in mcpp's invocation dir.
     mcpp::ui::info("build.mcpp", "running");
-    auto rres = mcpp::platform::process::capture_exec({bin.string()});
+    auto rres = mcpp::platform::process::capture_exec({bin.string()}, {}, root.string());
     if (rres.exit_code != 0) {
         return std::unexpected(std::format(
             "build.mcpp exited with {} (build aborted):\n{}", rres.exit_code, rres.output));

src/platform/process.cppm

@@ -19,6 +19,9 @@
 // Callers are responsible for shell-quoting arguments (see platform.shell).
 
 module;
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE        // for posix_spawn_file_actions_addchdir_np (glibc)
+#endif
 #include <cstdio>
 #include <cstdlib>
 #if defined(_WIN32)
@@ -77,7 +80,8 @@ int run_exec(const std::vector<std::string>& argv,
 // is_stale_ninja_failure / filter_ninja_output. No shell → no quoting/injection.
 RunResult capture_exec(
     const std::vector<std::string>& argv,
-    const std::vector<std::pair<std::string, std::string>>& extraEnv = {});
+    const std::vector<std::pair<std::string, std::string>>& extraEnv = {},
+    std::string_view cwd = {});
 
 // Run `command` silently (discard stdout/stderr).
 // On POSIX, stdin is automatically redirected from /dev/null.
@@ -325,7 +329,8 @@ int run_exec(const std::vector<std::string>& argv,
 
 RunResult capture_exec(
     const std::vector<std::string>& argv,
-    const std::vector<std::pair<std::string, std::string>>& extraEnv)
+    const std::vector<std::pair<std::string, std::string>>& extraEnv,
+    std::string_view cwd)
 {
     RunResult result;
     if (argv.empty()) { result.exit_code = 127; return result; }
@@ -345,6 +350,11 @@ RunResult capture_exec(
 
     posix_spawn_file_actions_t fa;
     ::posix_spawn_file_actions_init(&fa);
+    // Run the child in `cwd` when requested (e.g. build.mcpp, whose relative
+    // file writes must land in the project root regardless of mcpp's own cwd).
+    std::string cwdStore(cwd);
+    if (!cwdStore.empty())
+        ::posix_spawn_file_actions_addchdir_np(&fa, cwdStore.c_str());
     ::posix_spawn_file_actions_adddup2(&fa, fds[1], 1);  // stdout → pipe
     ::posix_spawn_file_actions_adddup2(&fa, fds[1], 2);  // stderr → same pipe
     ::posix_spawn_file_actions_addclose(&fa, fds[0]);
@@ -367,6 +377,8 @@ RunResult capture_exec(
     return result;
 #else
     std::string cmd = command_from_argv(argv) + " 2>&1";
+    if (!cwd.empty())
+        cmd = "cd " + mcpp::platform::shell::quote(cwd) + " && " + cmd;
     return capture_with_env(cmd, extraEnv);
 #endif
 }

tests/e2e/89_build_mcpp.sh

@@ -67,4 +67,36 @@ touch src/main.cpp
 MCPP_TEST_TOGGLE=1 "$MCPP" build > b3.log 2>&1 || { cat b3.log; echo "FAIL: build 3 errored"; exit 1; }
 grep -qi "build.mcpp.*\(running\|compiling\)" b3.log || { cat b3.log; echo "FAIL: changed env did not force build.mcpp re-run"; exit 1; }
 
+# ── CWD independence: build.mcpp must run with cwd = project root, so its
+#    relative file writes (the generated source) land in the project even when
+#    mcpp is invoked from a SUBDIRECTORY (e.g. workspace -p, or `cd src && mcpp`).
+cd "$TMP"
+mkdir -p sub/src
+cat > sub/mcpp.toml <<'EOF'
+[package]
+name    = "sub"
+version = "0.1.0"
+EOF
+cat > sub/src/main.cpp <<'EOF'
+#ifndef FROM_BUILD_MCPP
+#error "define missing"
+#endif
+int gen();
+int main() { return gen() == 7 ? 0 : 1; }
+EOF
+cat > sub/build.mcpp <<'EOF'
+#include <fstream>
+#include <cstdio>
+int main() {
+    std::ofstream("src/gen.cpp") << "int gen(){return 7;}\n";
+    std::puts("mcpp:generated=src/gen.cpp");
+    std::puts("mcpp:cxxflag=-DFROM_BUILD_MCPP=1");
+    return 0;
+}
+EOF
+# Invoke from the nested src/ dir — mcpp walks up to the project; build.mcpp must
+# still write src/gen.cpp into the project root, not into the cwd.
+( cd sub/src && "$MCPP" build > "$TMP/sub.log" 2>&1 ) || { cat "$TMP/sub.log"; echo "FAIL: build from subdir errored (cwd not project root?)"; exit 1; }
+[ -f sub/src/gen.cpp ] || { echo "FAIL: generated source not written to project root"; exit 1; }
+
 echo "OK"