feat: Windows self-host — POSIX compat fixes + LLVM toolchain config

- mcpp.toml: add windows = "llvm@20.1.7" so mcpp uses LLVM on Windows
- probe.cppm: guard LD_LIBRARY_PATH env prefix, command -v, and
  /dev/null redirects behind #if !defined(_WIN32)
- xlings.cppm: Windows-specific build_command_prefix using cmd.exe
  set/cd semantics instead of env -u / POSIX PATH prepend; fix shq()
  to use double quotes on Windows; fix 2>/dev/null → 2>/dev/null
- config.cppm: use "where xlings.exe" instead of "command -v xlings"
- clang.cppm: fix /dev/null redirect in module manifest probe
- CI: re-enable self-host step (mcpp builds itself using LLVM)

Author: Sunrisepeak

.github/workflows/ci-windows.yml

@@ -3,8 +3,8 @@ name: ci-windows
 # Windows validation CI for mcpp.
 # Step 1: Verify xlings LLVM toolchain capabilities on Windows.
 # Step 2: xmake bootstrap to produce first mcpp.exe.
-# Step 3: Package into a distributable zip (same layout as Linux/macOS).
-# NOTE: self-host (mcpp building itself) not yet possible — needs MSVC toolchain support.
+# Step 3: Self-host — use the bootstrapped mcpp.exe to build itself (via LLVM).
+# Step 4: Package into a distributable zip (same layout as Linux/macOS).
 
 on:
   push:
@@ -233,12 +233,38 @@ jobs:
               exit 1
           }
 
-      # NOTE: full self-host (`mcpp build` building itself) is not yet
-      # possible on Windows — mcpp's build system defaults to gcc which
-      # is unavailable here. Once mcpp.toml gains a `windows = "msvc"`
-      # toolchain override (and detect.cppm handles MSVC output), the
-      # self-host step can be re-enabled.  For now we package the xmake-
-      # bootstrapped binary, which is functionally identical.
+      - name: Self-host — mcpp builds itself
+        shell: bash
+        run: |
+          echo "=== Self-host: using bootstrapped mcpp.exe to build mcpp ==="
+          # Save bootstrap binary before cleaning xmake artifacts
+          mkdir -p /tmp/mcpp-bootstrap
+          cp "$MCPP_BOOTSTRAP" /tmp/mcpp-bootstrap/mcpp.exe
+          MCPP_EXE="/tmp/mcpp-bootstrap/mcpp.exe"
+
+          # Clean xmake artifacts so mcpp starts fresh
+          rm -rf build xmake.lua .xmake
+
+          echo "Bootstrap binary: $MCPP_EXE"
+          "$MCPP_EXE" --version
+
+          # mcpp build uses its own build system; mcpp.toml now has
+          # windows = "llvm@20.1.7" so it will use the xlings LLVM.
+          export MCPP_VENDORED_XLINGS="$USERPROFILE/.xlings/subos/default/bin/xlings.exe"
+          "$MCPP_EXE" build
+
+          # Find the self-hosted binary
+          SELF_MCPP=$(find target -name "mcpp.exe" -path "*/bin/*" | head -1)
+          test -n "$SELF_MCPP" || {
+            echo "FAIL: self-host build did not produce mcpp.exe"
+            find target -name "*.exe" 2>/dev/null
+            exit 1
+          }
+          SELF_MCPP=$(cd "$(dirname "$SELF_MCPP")" && pwd)/$(basename "$SELF_MCPP")
+          echo "Self-hosted binary: $SELF_MCPP"
+          "$SELF_MCPP" --version
+
+          echo "MCPP_SELF=$SELF_MCPP" >> "$GITHUB_ENV"
 
       - name: Package Windows release zip
         id: package
@@ -255,8 +281,8 @@ jobs:
           mkdir -p "$STAGING/$WRAPPER/bin"
           mkdir -p "$STAGING/$WRAPPER/registry/bin"
 
-          # Binary
-          cp "$MCPP_BOOTSTRAP" "$STAGING/$WRAPPER/bin/mcpp.exe"
+          # Binary (use self-hosted build if available, fall back to bootstrap)
+          cp "${MCPP_SELF:-$MCPP_BOOTSTRAP}" "$STAGING/$WRAPPER/bin/mcpp.exe"
 
           # Launcher batch script (equivalent to the shell wrapper on Linux/macOS)
           printf '@echo off\r\n"%%~dp0bin\\mcpp.exe" %%*\r\n' > "$STAGING/$WRAPPER/mcpp.bat"

mcpp.toml

@@ -14,6 +14,7 @@ include_dirs = ["src/libs/json"]
 [toolchain]
 default = "gcc@16.1.0"
 macos   = "llvm@20.1.7"
+windows = "llvm@20.1.7"
 
 # Per-target overrides: `mcpp build --target x86_64-linux-musl` (or the
 # four-segment form `x86_64-unknown-linux-musl`) picks musl-gcc 15.1 + full

src/config.cppm

@@ -355,7 +355,11 @@ acquire_xlings_binary(const std::filesystem::path& destBin, bool quiet)
     }
 
     // 2. Copy from system (`which xlings`)
+#if defined(_WIN32)
+    auto sys = run_capture("where xlings.exe 2>nul");
+#else
     auto sys = run_capture("command -v xlings 2>/dev/null");
+#endif
     if (sys) {
         std::string p = *sys;
         while (!p.empty() && (p.back() == '\n' || p.back() == '\r')) p.pop_back();
@@ -532,7 +536,11 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
         auto xbin = acquire_xlings_binary(cfg.xlingsBinary, quiet);
         if (!xbin) return std::unexpected(ConfigError{xbin.error()});
     } else if (cfg.xlingsBinaryMode == "system") {
+#if defined(_WIN32)
+        auto sys = run_capture("where xlings.exe 2>nul");
+#else
         auto sys = run_capture("command -v xlings 2>/dev/null");
+#endif
         if (!sys || sys->empty())
             return std::unexpected(ConfigError{"system xlings not found in PATH"});
         std::string p = *sys;

src/toolchain/clang.cppm

@@ -88,10 +88,16 @@ std::optional<std::filesystem::path> find_libcxx_std_module_source(
     const std::filesystem::path& cxx_binary,
     const std::string& envPrefix)
 {
+#if defined(_WIN32)
+    constexpr auto kDevNull = "2>nul";
+#else
+    constexpr auto kDevNull = "2>/dev/null";
+#endif
     auto manifest_r = mcpp::toolchain::run_capture(std::format(
-        "{}{} -print-library-module-manifest-path 2>/dev/null",
+        "{}{} -print-library-module-manifest-path {}",
         envPrefix,
-        mcpp::xlings::shq(cxx_binary.string())));
+        mcpp::xlings::shq(cxx_binary.string()),
+        kDevNull));
     if (manifest_r) {
         auto manifestPath = std::filesystem::path(
             mcpp::toolchain::trim_line(*manifest_r));

src/toolchain/probe.cppm

@@ -70,10 +70,15 @@ std::string join_colon_paths(const std::vector<std::filesystem::path>& dirs) {
 }
 
 std::string env_prefix_for_dirs(const std::vector<std::filesystem::path>& dirs) {
+#if defined(_WIN32)
+    (void)dirs;
+    return "";
+#else
     if (dirs.empty()) return "";
     auto joined = join_colon_paths(dirs);
     return std::format("env LD_LIBRARY_PATH={}${{LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}} ",
                        mcpp::xlings::shq(joined));
+#endif
 }
 
 } // namespace
@@ -244,7 +249,11 @@ probe_compiler_binary(const std::filesystem::path& explicit_compiler) {
         cxx = "g++";
     }
 
+#if defined(_WIN32)
+    auto bin_path_r = run_capture(std::format("where {} 2>nul", cxx));
+#else
     auto bin_path_r = run_capture(std::format("command -v '{}' 2>/dev/null", cxx));
+#endif
     if (!bin_path_r) {
         return std::unexpected(DetectError{std::format("compiler '{}' not found in PATH", cxx)});
     }
@@ -258,19 +267,31 @@ probe_compiler_binary(const std::filesystem::path& explicit_compiler) {
 std::expected<std::string, DetectError>
 probe_target_triple(const std::filesystem::path& compilerBin,
                     const std::string& envPrefix) {
-    auto triple_r = run_capture(std::format("{}{} -dumpmachine 2>/dev/null",
+#if defined(_WIN32)
+    constexpr auto kNullRedirect = "2>nul";
+#else
+    constexpr auto kNullRedirect = "2>/dev/null";
+#endif
+    auto triple_r = run_capture(std::format("{}{} -dumpmachine {}",
                                             envPrefix,
-                                            mcpp::xlings::shq(compilerBin.string())));
+                                            mcpp::xlings::shq(compilerBin.string()),
+                                            kNullRedirect));
     if (!triple_r) return std::unexpected(triple_r.error());
     return trim_line(*triple_r);
 }
 
 std::filesystem::path
 probe_sysroot(const std::filesystem::path& compilerBin,
               const std::string& envPrefix) {
-    auto r = run_capture(std::format("{}{} -print-sysroot 2>/dev/null",
+#if defined(_WIN32)
+    constexpr auto kNullRedir = "2>nul";
+#else
+    constexpr auto kNullRedir = "2>/dev/null";
+#endif
+    auto r = run_capture(std::format("{}{} -print-sysroot {}",
                                      envPrefix,
-                                     mcpp::xlings::shq(compilerBin.string())));
+                                     mcpp::xlings::shq(compilerBin.string()),
+                                     kNullRedir));
     if (r) {
         auto s = trim_line(*r);
         if (!s.empty() && std::filesystem::exists(s)) return s;

src/xlings.cppm

@@ -319,12 +319,22 @@ std::expected<std::string, std::string> run_capture(const std::string& cmd) {
 std::string shq(std::string_view s) {
     std::string out;
     out.reserve(s.size() + 2);
+#if defined(_WIN32)
+    // cmd.exe uses double quotes; escape inner double quotes with backslash
+    out.push_back('"');
+    for (char c : s) {
+        if (c == '"') out += "\\\"";
+        else out.push_back(c);
+    }
+    out.push_back('"');
+#else
     out.push_back('\'');
     for (char c : s) {
         if (c == '\'') out += "'\\''";
         else out.push_back(c);
     }
     out.push_back('\'');
+#endif
     return out;
 }
 
@@ -413,6 +423,24 @@ std::filesystem::path sandbox_init_marker(const Env& env) {
 
 std::string build_command_prefix(const Env& env) {
     auto xvmBin = paths::sandbox_bin(env).string();
+#if defined(_WIN32)
+    // Windows: use cmd.exe set + call semantics.
+    if (env.projectDir.empty()) {
+        return std::format(
+            "cd /d {} && set \"PATH={};%PATH%\" && set \"XLINGS_HOME={}\" && set \"XLINGS_PROJECT_DIR=\" && {}",
+            shq(env.home.string()),
+            xvmBin,
+            env.home.string(),
+            shq(env.binary.string()));
+    }
+    return std::format(
+        "cd /d {} && set \"PATH={};%PATH%\" && set \"XLINGS_HOME={}\" && set \"XLINGS_PROJECT_DIR={}\" && {}",
+        shq(env.home.string()),
+        xvmBin,
+        env.home.string(),
+        env.projectDir.string(),
+        shq(env.binary.string()));
+#else
     if (env.projectDir.empty()) {
         // Global mode: unset XLINGS_PROJECT_DIR (existing behavior).
         return std::format(
@@ -431,13 +459,19 @@ std::string build_command_prefix(const Env& env) {
         shq(env.home.string()),
         shq(env.projectDir.string()),
         shq(env.binary.string()));
+#endif
 }
 
 std::string build_interface_command(const Env& env,
                                     std::string_view capability,
                                     std::string_view argsJson) {
+#if defined(_WIN32)
+    return std::format("{} interface {} --args {} 2>nul",
+        build_command_prefix(env), capability, shq(argsJson));
+#else
     return std::format("{} interface {} --args {} 2>/dev/null",
         build_command_prefix(env), capability, shq(argsJson));
+#endif
 }
 
 // ─── JSON extraction helpers ────────────────────────────────────────
@@ -628,12 +662,21 @@ int install_with_progress(const Env& env, std::string_view target,
     auto argsJson = std::format(
         R"({{"targets":["{}"],"yes":true}})", target);
 
+#if defined(_WIN32)
+    auto cmd = std::format(
+        "cd /d {} && set \"XLINGS_PROJECT_DIR=\" && set \"XLINGS_HOME={}\" && {} interface install_packages --args {} 2>nul",
+        shq(env.home.string()),
+        env.home.string(),
+        shq(env.binary.string()),
+        shq(argsJson));
+#else
     auto cmd = std::format(
         "cd {} && env -u XLINGS_PROJECT_DIR XLINGS_HOME={} {} interface install_packages --args {} 2>/dev/null",
         shq(env.home.string()),
         shq(env.home.string()),
         shq(env.binary.string()),
         shq(argsJson));
+#endif
 
     std::FILE* fp = ::popen(cmd.c_str(), "r");
     if (!fp) return -1;
@@ -746,11 +789,19 @@ void ensure_init(const Env& env, bool quiet) {
 
     if (!quiet)
         print_status("Initialize", "mcpp sandbox layout (one-time)");
+#if defined(_WIN32)
+    auto cmd = std::format(
+        "cd /d {} && set \"XLINGS_PROJECT_DIR=\" && set \"XLINGS_HOME={}\" && {} self init >nul 2>&1",
+        shq(env.home.string()),
+        env.home.string(),
+        shq(env.binary.string()));
+#else
     auto cmd = std::format(
         "cd {} && env -u XLINGS_PROJECT_DIR XLINGS_HOME={} {} self init >/dev/null 2>&1",
         shq(env.home.string()),
         shq(env.home.string()),
         shq(env.binary.string()));
+#endif
     int rc = std::system(cmd.c_str());
     if (rc != 0 && !quiet) {
         std::println(stderr,