// mcpp.config — global config + paths + xlings binary acquisition.

//

// Layout (per docs/14-data-layout.md):

// $MCPP_HOME/ default ~/.mcpp/

// bin/mcpp mcpp binary (self-contained mode)

// registry/ XLINGS_HOME for mcpp's xlings

// bin/xlings vendored xlings binary (= <XLINGS_HOME>/bin/xlings)

// .xlings.json seeded with index_repos = [mcpplibs]

// bmi/<fp>/ BMI cache (existing)

// cache/ metadata caches

// config.toml this module's input

//

// Initialization is silent and idempotent: every Config::load() ensures

// the directory tree exists and seeds .xlings.json if missing.

module;

#include <cstdlib>

#include <cstdio>

export module mcpp.config;

import std;

import mcpp.libs.toml;

import mcpp.pm.index_spec;

import mcpp.xlings;

import mcpp.platform;

import mcpp.log;

import mcpp.fallback.xlings_binary;

import mcpp.fallback.config_migration;

import mcpp.fallback.install_integrity;

export namespace mcpp::config {

inline constexpr std::string_view kXlingsPinnedVersion = mcpp::xlings::pinned::kXlingsVersion;

struct IndexRepo {

std::string name;

std::string url;

};

struct GlobalConfig {

// Resolved paths

std::filesystem::path mcppHome; // ~/.mcpp/

std::filesystem::path binDir; // mcppHome/bin

std::filesystem::path xlingsBinary; // mcppHome/registry/bin/xlings

std::filesystem::path registryDir; // mcppHome/registry

std::filesystem::path bmiCacheDir; // mcppHome/bmi

std::filesystem::path metaCacheDir; // mcppHome/cache

std::filesystem::path logDir; // mcppHome/log

std::filesystem::path configFile; // mcppHome/config.toml

// From config.toml [xlings]

std::string xlingsBinaryMode; // "bundled" | "system" | absolute path

std::filesystem::path xlingsHomeOverride; // empty = use registryDir

// From config.toml [index]

std::string defaultIndex; // "mcpplibs"

std::vector<IndexRepo> indexRepos;

// From config.toml [indices] — custom index repositories (new schema).

// Merged: project mcpp.toml > global config.toml > built-in default.

std::map<std::string, mcpp::pm::IndexSpec> indices;

// From config.toml [cache]

std::int64_t searchTtlSeconds = 3600;

// From config.toml [build]

std::int64_t defaultJobs = 0;

std::string defaultBackend = "ninja";

// From config.toml [toolchain] (M5.5)

// default = "<compiler>@<version>" e.g. "gcc@15.1.0"

// Empty means no global default; mcpp will hard-error unless the project

// mcpp.toml declares its own [toolchain].

std::string defaultToolchain;

// Resolved xlings home (registryDir unless overridden)

std::filesystem::path xlingsHome() const {

return xlingsHomeOverride.empty() ? registryDir : xlingsHomeOverride;

}

};

// Create an xlings::Env from the resolved GlobalConfig.

mcpp::xlings::Env make_xlings_env(const GlobalConfig& cfg) {

#if defined(_WIN32)

// On Windows, the copied xlings binary in the sandbox may not function

// correctly for large package installs (missing runtime environment).

// When MCPP_VENDORED_XLINGS is set, use the original xlings binary

// directly — it has the full xlings runtime. The XLINGS_HOME env var

// ensures packages are installed into the mcpp sandbox.

if (auto* e = std::getenv("MCPP_VENDORED_XLINGS"); e && *e) {

std::filesystem::path vendored{e};

if (std::filesystem::exists(vendored))

return { vendored, cfg.xlingsHome() };

}

#endif

return { cfg.xlingsBinary, cfg.xlingsHome() };

}

// Create an xlings::Env that targets the project-level .mcpp/ directory.

// Used when custom (non-builtin) indices are configured in mcpp.toml.

mcpp::xlings::Env make_project_xlings_env(const GlobalConfig& cfg,

const std::filesystem::path& projectDir) {

return { cfg.xlingsBinary, cfg.xlingsHome(), projectDir / ".mcpp" };

}

std::vector<std::filesystem::path>

project_xlings_data_roots(const std::filesystem::path& projectDir)

{

auto dotMcpp = projectDir / ".mcpp";

return {

dotMcpp / "data",

dotMcpp / ".xlings" / "data",

};

}

std::filesystem::path

resolve_project_index_path(const std::filesystem::path& projectDir,

const mcpp::pm::IndexSpec& spec)

{

auto source = spec.path;

if (source.is_relative()) source = projectDir / source;

return source.lexically_normal();

}

bool project_index_data_initialized(const std::filesystem::path& projectDir)

{

std::error_code ec;

for (auto const& data : project_xlings_data_roots(projectDir)) {

auto reposDir = data / "xim-index-repos";

if (std::filesystem::exists(reposDir / "xim-indexrepos.json", ec)) {

return true;

}

if (std::filesystem::is_directory(reposDir, ec)) {

for (auto const& entry : std::filesystem::directory_iterator(reposDir, ec)) {

if (entry.is_directory(ec) && std::filesystem::exists(entry.path() / "pkgs", ec)) {

return true;

}

}

}

if (std::filesystem::is_directory(data, ec)) {

for (auto const& entry : std::filesystem::directory_iterator(data, ec)) {

if (entry.is_directory(ec) && std::filesystem::exists(entry.path() / "pkgs", ec)) {

return true;

}

}

}

}

return false;

}

// Check that the sandbox bootstrap completed successfully.

// Returns empty string if ok, or a description of what's missing.

std::string check_base_init(const GlobalConfig& cfg) {

auto xlEnv = make_xlings_env(cfg);

struct Check { std::string_view name; std::filesystem::path path; };

auto patchelfBin = mcpp::xlings::paths::xim_tool(xlEnv, "patchelf",

mcpp::xlings::pinned::kPatchelfVersion) / "bin" / "patchelf";

auto ninjaRoot = mcpp::xlings::paths::xim_tool_root(xlEnv, "ninja");

auto ninja_name = std::string("ninja") + std::string(mcpp::platform::exe_suffix);

// Check xlings binary

if (!std::filesystem::exists(cfg.xlingsBinary))

return std::format("xlings binary missing: {}", cfg.xlingsBinary.string());

// Check sandbox init marker

auto marker = xlEnv.home / "subos" / "default" / ".xlings.json";

if (!std::filesystem::exists(marker))

return "sandbox not initialized (missing subos/default/.xlings.json)";

// Check patchelf (Linux only)

#if !defined(__APPLE__) && !defined(_WIN32)

if (!std::filesystem::exists(patchelfBin))

return std::format("patchelf missing: {}", patchelfBin.string());

#endif

// Check ninja

bool ninjaOk = false;

if (std::filesystem::exists(ninjaRoot)) {

std::error_code ec;

for (auto& v : std::filesystem::directory_iterator(ninjaRoot, ec)) {

if (std::filesystem::exists(v.path() / ninja_name)) { ninjaOk = true; break; }

}

}

if (!ninjaOk)

return "ninja missing from sandbox";

return {}; // all ok

}

// Delete the registry directory (sandbox) for a clean re-init.

// Preserves: bin/mcpp (self-contained mode), config.toml, log/.

void reset_registry(const GlobalConfig& cfg) {

std::error_code ec;

auto registry = cfg.xlingsHome();

if (std::filesystem::exists(registry))

std::filesystem::remove_all(registry, ec);

// Also clear BMI and metadata caches (stale after registry reset).

if (std::filesystem::exists(cfg.bmiCacheDir))

std::filesystem::remove_all(cfg.bmiCacheDir, ec);

if (std::filesystem::exists(cfg.metaCacheDir))

std::filesystem::remove_all(cfg.metaCacheDir, ec);

}

// Ensure the project-level .mcpp/ directory exists and contains a

// .xlings.json seeded with custom non-builtin index entries

// entries. Returns true if a .mcpp/ directory was created/updated.

bool ensure_project_index_dir(

const GlobalConfig& cfg,

const std::filesystem::path& projectDir,

const std::map<std::string, mcpp::pm::IndexSpec>& indices);

struct ConfigError { std::string message; };

// Load (or create) the global config. Idempotent. Performs:

// 1. Resolve $MCPP_HOME (env or ~/.mcpp)

// 2. Create directory tree if missing

// 3. Seed config.toml if missing

// 4. Seed registry/.xlings.json if missing (so xlings won't auto-add awesome)

// 5. Acquire xlings binary if missing (system copy → release download → fail)

// Streaming download-progress info for the sandbox bootstrap step (patchelf,

// ninja). cli.cppm wraps a ui::ProgressBar around this so the user sees the

// same percent / MB / s display they get for `mcpp toolchain install`.

//

// We can't use mcpp.fetcher's EventHandler here because fetcher imports

// config — the dependency would be cyclic.

using BootstrapFile = mcpp::xlings::BootstrapFile;

using BootstrapProgress = mcpp::xlings::BootstrapProgress;

using BootstrapProgressCallback = mcpp::xlings::BootstrapProgressCallback;

// `initial_mirror`: when seeding a *fresh* .xlings.json (file did not

// already exist), use this as the mirror value instead of the default.

// Empty means "use the default". Used by `mcpp self config --mirror X`

// so that the very first network roundtrip (during the immediately-

// following xlings sandbox bootstrap) goes through the user's chosen

// mirror, not the historical CN default. No effect when .xlings.json

// already exists — that case is handled by xlings::config_set_mirror.

std::expected<GlobalConfig, ConfigError> load_or_init(

bool quiet = false,

BootstrapProgressCallback onBootstrapProgress = {},

std::string_view initial_mirror = {});

// Pretty-print resolved config for `mcpp env` command.

void print_env(const GlobalConfig& cfg);

// M5.5: persist [toolchain].default to config.toml.

std::expected<void, ConfigError>

write_default_toolchain(const GlobalConfig& cfg, std::string_view spec);

} // namespace mcpp::config

namespace mcpp::config {

namespace t = mcpp::libs::toml;

namespace {

// Resolve MCPP_HOME, in priority order:

// 1. $MCPP_HOME env var (explicit override — used by CI / dev / multi-instance)

// 2. <binary-dir>/.. — self-contained mode, when mcpp lives at

// <root>/bin/mcpp. Release tarballs and `xlings install mcpp`

// use this layout; the unpacked tree IS the home. Dev builds

// live under target/<triple>/<fp>/bin/mcpp, which is the same

// "in a bin/ dir" shape — so we additionally exclude any path

// with a "target" ancestor as mcpp's own dev convention.

// 3. fallback to $HOME/.mcpp.

// Right-pad a verb to 12 columns, matching mcpp::ui::verb_padded so the

// bootstrap status lines line up under the cyan "Downloading …" lines

// produced via the BootstrapProgressCallback. We can't import mcpp.ui

// from here (cyclic dep), so this is a tiny duplicate of that helper —

// no color, no fanciness.

void print_status(std::string_view verb, std::string_view msg) {

constexpr std::size_t W = 12;

if (verb.size() >= W) {

std::println("{} {}", verb, msg);

} else {

std::println("{}{} {}", std::string(W - verb.size(), ' '), verb, msg);

}

}

std::filesystem::path default_mcpp_home() {

// Windows: %USERPROFILE%\.mcpp POSIX: $HOME/.mcpp

if constexpr (mcpp::platform::is_windows) {

if (auto* e = std::getenv("USERPROFILE"); e && *e)

return std::filesystem::path(e) / ".mcpp";

}

if (auto* e = std::getenv("HOME"); e && *e)

return std::filesystem::path(e) / ".mcpp";

return std::filesystem::current_path() / ".mcpp";

}

std::filesystem::path home_dir() {

// 1. Explicit $MCPP_HOME takes priority (CI, advanced users).

if (auto* e = std::getenv("MCPP_HOME"); e && *e)

return std::filesystem::path(e);

auto exe = mcpp::platform::fs::self_exe_path();

if (exe.has_parent_path() && exe.parent_path().filename() == "bin") {

auto candidate = exe.parent_path().parent_path();

// Disqualify self-contained mode for two cases:

// a) Dev builds: .../target/<triple>/<fp>/bin/<exe>

// b) xlings packages: .../data/xpkgs/xim-x-mcpp/<ver>/bin/mcpp

// Creating a nested xlings sandbox inside the xpkgs directory

// breaks toolchain installation (nested XLINGS_HOME) and loses

// installed toolchains when the mcpp package version is upgraded.

bool disqualified = false;

for (auto p = candidate;

p.has_parent_path() && p != p.root_path();

p = p.parent_path()) {

if (p.filename() == "target") { disqualified = true; break; }

if (p.filename() == "xpkgs") {

auto parent = p.parent_path().filename().string();

if (parent == "data") { disqualified = true; break; }

}

}

if (!disqualified)

return candidate;

}

return default_mcpp_home();

}

std::expected<std::string, std::string> run_capture(const std::string& cmd) {

return mcpp::xlings::run_capture(cmd);

}

void write_file(const std::filesystem::path& p, std::string_view content) {

std::error_code ec;

std::filesystem::create_directories(p.parent_path(), ec);

std::ofstream os(p);

os << content;

}

bool write_default_config_toml(const std::filesystem::path& path) {

constexpr auto tmpl = R"(# mcpp global config — auto-generated; safe to edit.

[xlings]

# binary: "bundled" (use $MCPP_HOME/registry/bin/xlings) | "system" | absolute path

binary = "bundled"

# home: empty = use $MCPP_HOME/registry; can override

home = ""

[index]

default = "mcpplibs"

[index.repos."mcpplibs"]

url = "https://github.com/mcpp-community/mcpp-index.git"

# xlings auto-adds xim / awesome / scode / d2x as defaults.

[cache]

search_ttl_seconds = 3600

[build]

default_jobs = 0

default_backend = "ninja"

)";

write_file(path, tmpl);

return std::filesystem::exists(path);

}

bool write_default_xlings_json(const std::filesystem::path& path,

const std::vector<IndexRepo>& repos,

std::string_view mirror_override = {})

{

// Delegate to xlings module. Convert IndexRepo vec to pair span.

std::vector<std::pair<std::string,std::string>> pairs;

pairs.reserve(repos.size());

for (auto& r : repos) pairs.emplace_back(r.name, r.url);

// seed_xlings_json writes to env.home / ".xlings.json", so we

// construct a temporary Env with home = path.parent_path().

mcpp::xlings::Env env;

env.home = path.parent_path();

if (mirror_override.empty())

mcpp::xlings::seed_xlings_json(env, pairs);

else

mcpp::xlings::seed_xlings_json(env, pairs, mirror_override);

return std::filesystem::exists(path);

}

// Migration helpers delegated to mcpp.fallback.config_migration.

void canonicalize_legacy_index_names(GlobalConfig& cfg) {

if (cfg.defaultIndex == "mcpp-index")

cfg.defaultIndex = "mcpplibs";

std::vector<IndexRepo> normalized;

for (auto r : cfg.indexRepos) {

if (r.name == "mcpp-index"

&& r.url == "https://github.com/mcpp-community/mcpp-index.git") {

r.name = "mcpplibs";

}

bool duplicate = std::any_of(normalized.begin(), normalized.end(),

[&](const IndexRepo& existing) {

return existing.name == r.name && existing.url == r.url;

});

if (!duplicate) normalized.push_back(std::move(r));

}

cfg.indexRepos = std::move(normalized);

}

// Xlings binary acquisition delegated to mcpp.fallback.xlings_binary.

// Run `xlings self init` against the sandbox to create the standard

// directory layout (subos/default/{bin,lib,usr,generations}, data/, config/,

// shell profiles, and the empty workspace .xlings.json). Idempotent.

//

// TODO(xlings-upstream): Once xlings ships a `xlings sandbox bootstrap` /

// `xlings self init --copy-self-bin` API that does init + binary placement

// + patchelf in one shot, this function and ensure_sandbox_xlings_binary +

// ensure_sandbox_patchelf below can collapse into a single call.

void ensure_sandbox_init(const GlobalConfig& cfg, bool quiet) noexcept {

mcpp::xlings::ensure_init(make_xlings_env(cfg), quiet);

}

// With the 0.0.4 layout change (xlings binary at <MCPP_HOME>/registry/bin/

// = <XLINGS_HOME>/bin/), the bundled xlings IS already at the path xlings's

// shim-creation guard checks (`paths.homeDir / "bin" / "xlings"`).

// No mirroring / hardlinking needed — this function is now a no-op.

void ensure_sandbox_xlings_binary(const GlobalConfig& /*cfg*/, bool /*quiet*/) noexcept {

// Intentional no-op: xlingsBinary == xlingsHome()/bin/xlings.

}

// Bootstrap install: delegated to mcpp.xlings module.

void ensure_sandbox_ninja(const GlobalConfig& cfg, bool quiet,

const BootstrapProgressCallback& cb) noexcept

{

mcpp::xlings::ensure_ninja(make_xlings_env(cfg), quiet, cb);

}

void ensure_sandbox_patchelf(const GlobalConfig& cfg, bool quiet,

const BootstrapProgressCallback& cb) noexcept

{

mcpp::xlings::ensure_patchelf(make_xlings_env(cfg), quiet, cb);

}

} // namespace

std::expected<GlobalConfig, ConfigError> load_or_init(

bool quiet,

BootstrapProgressCallback onBootstrapProgress,

std::string_view initial_mirror)

{

GlobalConfig cfg;

// 1. Resolve paths

cfg.mcppHome = home_dir();

cfg.binDir = cfg.mcppHome / "bin";

cfg.registryDir = cfg.mcppHome / "registry";

// xlings lives under registry/, not bin/ — it's a registry tool,

// not a user-facing binary. This also places it exactly at

// <XLINGS_HOME>/bin/xlings, which satisfies xlings's own shim-

// creation guard (`if fs::exists(homeDir/"bin"/"xlings")`),

// making ensure_sandbox_xlings_binary() a no-op.

cfg.xlingsBinary = cfg.registryDir / "bin" /

(std::string("xlings") + std::string(mcpp::platform::exe_suffix));

cfg.bmiCacheDir = cfg.mcppHome / "bmi";

cfg.metaCacheDir = cfg.mcppHome / "cache";

cfg.logDir = cfg.mcppHome / "log";

cfg.configFile = cfg.mcppHome / "config.toml";

// 2. Create directory tree

std::error_code ec;

for (auto& d : { cfg.binDir, cfg.registryDir, cfg.bmiCacheDir,

cfg.metaCacheDir, cfg.logDir }) {

std::filesystem::create_directories(d, ec);

if (ec) return std::unexpected(ConfigError{

std::format("cannot create '{}': {}", d.string(), ec.message())});

}

// 2b. Initialize logger (early init with defaults; re-init after config load)

{

mcpp::log::Config logCfg;

logCfg.logDir = cfg.logDir;

mcpp::log::init(logCfg);

}

// 3. Seed config.toml if missing

bool fresh_config = !std::filesystem::exists(cfg.configFile);

if (fresh_config) write_default_config_toml(cfg.configFile);

else mcpp::fallback::migrate_config_toml_index_names(cfg.configFile);

// 4. Load config.toml

auto doc = t::parse_file(cfg.configFile);

if (!doc) {

return std::unexpected(ConfigError{

std::format("invalid config.toml: {}", doc.error().message)});

}

cfg.xlingsBinaryMode = doc->get_string("xlings.binary").value_or("bundled");

if (auto h = doc->get_string("xlings.home"); h && !h->empty())

cfg.xlingsHomeOverride = *h;

cfg.defaultIndex = doc->get_string("index.default").value_or("mcpplibs");

cfg.searchTtlSeconds = doc->get_int("cache.search_ttl_seconds").value_or(3600);

cfg.defaultJobs = doc->get_int("build.default_jobs").value_or(0);

cfg.defaultBackend = doc->get_string("build.default_backend").value_or("ninja");

cfg.defaultToolchain = doc->get_string("toolchain.default").value_or("");

// [log] section — re-initialize logger with config values

{

mcpp::log::Config logCfg;

logCfg.logDir = cfg.logDir;

auto levelStr = doc->get_string("log.level").value_or("off");

if (levelStr == "debug") logCfg.level = mcpp::log::Level::debug;

else if (levelStr == "info") logCfg.level = mcpp::log::Level::info;

else if (levelStr == "warn") logCfg.level = mcpp::log::Level::warn;

else if (levelStr == "error") logCfg.level = mcpp::log::Level::error;

logCfg.maxFileSize = static_cast<std::size_t>(

doc->get_int("log.max_file_size").value_or(10 * 1024 * 1024));

logCfg.maxFiles = static_cast<int>(

doc->get_int("log.max_files").value_or(3));

mcpp::log::init(logCfg);

}

// [index.repos.NAME] tables

if (auto* repos = doc->get_table("index.repos")) {

for (auto& [name, val] : *repos) {

if (!val.is_table()) continue;

auto& tt = val.as_table();

auto it = tt.find("url");

if (it == tt.end() || !it->second.is_string()) continue;

cfg.indexRepos.push_back({ name, it->second.as_string() });

}

}

// [indices] — new-schema custom index repositories.

// Accepts the same short/long/path forms as mcpp.toml [indices].

if (auto* indices_t = doc->get_table("indices")) {

for (auto& [k, v] : *indices_t) {

mcpp::pm::IndexSpec spec;

spec.name = k;

if (v.is_string()) {

spec.url = v.as_string();

} else if (v.is_table()) {

auto& sub = v.as_table();

if (auto it = sub.find("url"); it != sub.end() && it->second.is_string()) spec.url = it->second.as_string();

if (auto it = sub.find("rev"); it != sub.end() && it->second.is_string()) spec.rev = it->second.as_string();

if (auto it = sub.find("tag"); it != sub.end() && it->second.is_string()) spec.tag = it->second.as_string();

if (auto it = sub.find("branch"); it != sub.end() && it->second.is_string()) spec.branch = it->second.as_string();

if (auto it = sub.find("path"); it != sub.end() && it->second.is_string()) spec.path = it->second.as_string();

}

if (!spec.url.empty() || !spec.path.empty())

cfg.indices[k] = std::move(spec);

}

}

// Defaults: only mcpplibs. xlings auto-adds its own standard

// defaults (xim / awesome / scode / d2x) because globalIndexRepos_

// is non-empty (per xlings/src/core/config.cppm). Explicitly listing

// them ourselves can cause cross-index name conflicts during

// dependency resolution (e.g. linux-headers existing in both

// scode and xim). See docs/21 §VII.

auto add_default = [&](std::string_view name, std::string_view url) {

for (auto& r : cfg.indexRepos) if (r.name == name) return;

cfg.indexRepos.push_back({ std::string(name), std::string(url) });

};

add_default("mcpplibs", "https://github.com/mcpp-community/mcpp-index.git");

canonicalize_legacy_index_names(cfg);

// 5. Seed registry/.xlings.json if missing; migrate legacy cached

// sandboxes in place so CI/user caches move from mcpp-index to mcpplibs

// without losing xlings' active subos or version bindings.

auto xjson = cfg.xlingsHome() / ".xlings.json";

if (!std::filesystem::exists(xjson)) {

write_default_xlings_json(xjson, cfg.indexRepos, initial_mirror);

} else {

mcpp::fallback::migrate_xlings_json_index_names(xjson);

}

// 6. Acquire xlings binary if needed

if (cfg.xlingsBinaryMode == "bundled") {

auto xbin = mcpp::fallback::acquire_xlings_binary(cfg.xlingsBinary, quiet);

if (!xbin) return std::unexpected(ConfigError{xbin.error()});

} else if (cfg.xlingsBinaryMode == "system") {

auto sysPath = mcpp::platform::fs::which(

std::string("xlings") + std::string(mcpp::platform::exe_suffix));

if (!sysPath)

return std::unexpected(ConfigError{"system xlings not found in PATH"});

cfg.xlingsBinary = *sysPath;

} else {

cfg.xlingsBinary = cfg.xlingsBinaryMode;

if (!std::filesystem::exists(cfg.xlingsBinary))

return std::unexpected(ConfigError{std::format(

"configured xlings binary not found: {}", cfg.xlingsBinary.string())});

}

// 7. Sandbox bootstrap (mcpp self-contained xlings environment).

// Order matters:

// a. Mirror xlings binary into sandbox so shim creation works.

// b. xlings self init: creates subos/default/{bin,lib,usr} skeleton.

// c. Install patchelf so xim install hooks can patch ELF binaries.

//

// TODO(xlings-upstream): collapse into a single

// `xlings sandbox bootstrap --home <X>` once that command exists

// upstream (see docs/short-term-vs-long-track plan).

ensure_sandbox_xlings_binary(cfg, quiet);

ensure_sandbox_init(cfg, quiet);

{

auto bsEnv = make_xlings_env(cfg);

#if !defined(__APPLE__) && !defined(_WIN32)

// patchelf is ELF-only; macOS uses Mach-O and Windows uses PE.

ensure_sandbox_patchelf(cfg, quiet, onBootstrapProgress);

// Only mark complete if the actual binary exists (not just the dir).

{

auto pBin = mcpp::xlings::paths::xim_tool(bsEnv, "patchelf",

mcpp::xlings::pinned::kPatchelfVersion) / "bin" / "patchelf";

if (std::filesystem::exists(pBin))

mcpp::fallback::mark_install_complete(pBin.parent_path().parent_path());

}

#endif

ensure_sandbox_ninja(cfg, quiet, onBootstrapProgress);

{

auto nRoot = mcpp::xlings::paths::xim_tool_root(bsEnv, "ninja");

auto ninja_name = std::string("ninja") + std::string(mcpp::platform::exe_suffix);

std::error_code ec;

if (std::filesystem::exists(nRoot)) {

for (auto& v : std::filesystem::directory_iterator(nRoot, ec)) {

if (std::filesystem::exists(v.path() / ninja_name))

mcpp::fallback::mark_install_complete(v.path());

}

}

}

}

// 8. Bootstrap check is NOT done here — it's deferred to commands that

// actually need bootstrap tools (build, run, toolchain install).

// Light commands (self env, toolchain list) should work even if

// bootstrap is incomplete. Commands call check_base_init() themselves.

return cfg;

}

void print_env(const GlobalConfig& cfg) {

std::println("MCPP_HOME = {}", cfg.mcppHome.string());

std::println("xlings binary = {}", cfg.xlingsBinary.string());

std::println("xlings home = {}", cfg.xlingsHome().string());

std::println("config = {}", cfg.configFile.string());

std::println("BMI cache = {}", cfg.bmiCacheDir.string());

std::println("meta cache = {}", cfg.metaCacheDir.string());

if (!cfg.defaultToolchain.empty())

std::println("default toolchain = {}", cfg.defaultToolchain);

else

std::println("default toolchain = (none — run `mcpp toolchain install gcc 16.1.0`)");

std::println("");

std::println("Index repos:");

for (auto& r : cfg.indexRepos) {

bool isDefault = (r.name == cfg.defaultIndex);

std::println(" {} {}{}",

r.name, r.url, isDefault ? " (default)" : "");

}

}

bool ensure_project_index_dir(

const GlobalConfig& cfg,

const std::filesystem::path& projectDir,

const std::map<std::string, mcpp::pm::IndexSpec>& indices)

{

// Collect custom non-builtin indices that need xlings project-scope data.

// Local path indices are also seeded so xlings can create its own

// project-local repo link and install packages from that index.

std::vector<std::pair<std::string,std::string>> customRepos;

for (auto& [name, spec] : indices) {

if (spec.is_builtin()) continue;

if (spec.is_local()) {

auto source = resolve_project_index_path(projectDir, spec);

std::error_code ec;

std::filesystem::remove(source / ".xlings-index-cache.json", ec);

customRepos.emplace_back(name, source.generic_string());

continue;

}

customRepos.emplace_back(name, spec.url);

}

auto officialIndex = cfg.xlingsHome() / "data" / "xim-pkgindex";

std::error_code ec;

if (!customRepos.empty() && std::filesystem::exists(officialIndex / "pkgs", ec)) {

bool hasXim = false;

for (auto const& [name, _] : customRepos) {

if (name == "xim") {

hasXim = true;

break;

}

}

if (!hasXim) {

customRepos.emplace_back("xim", officialIndex.generic_string());

}

}

if (customRepos.empty()) return false; // nothing to do

auto dotMcpp = projectDir / ".mcpp";

std::filesystem::create_directories(dotMcpp, ec);

// Seed .xlings.json with the custom index entries.

mcpp::xlings::Env env;

env.home = dotMcpp;

mcpp::xlings::seed_xlings_json(env, customRepos);

auto exposeLocalIndex = [&](const std::string& name,

const std::filesystem::path& source,

const std::filesystem::path& dataRoot)

{

std::error_code ec2;

auto target = dataRoot / name;

std::filesystem::create_directories(dataRoot, ec2);

if (std::filesystem::exists(target / "pkgs", ec2)) {

return;

}

ec2.clear();

if (std::filesystem::exists(target, ec2) || std::filesystem::is_symlink(target, ec2)) {

std::filesystem::remove_all(target, ec2);

}

ec2.clear();

std::filesystem::create_directory_symlink(source, target, ec2);

if (!ec2 && std::filesystem::exists(target / "pkgs", ec2)) {

return;

}

ec2.clear();

std::filesystem::copy(

source,

target,

std::filesystem::copy_options::recursive

| std::filesystem::copy_options::skip_existing,

ec2);

};

for (auto& [name, spec] : indices) {

if (spec.is_builtin() || !spec.is_local()) continue;

auto source = resolve_project_index_path(projectDir, spec);

if (!std::filesystem::exists(source / "pkgs", ec)) continue;

exposeLocalIndex(name, source, dotMcpp / ".xlings" / "data");

exposeLocalIndex(name, source, dotMcpp / "data");

}

// Project-scoped xlings installs custom-index packages in an additive

// project data dir. Expose the global official xim index there too, so

// package deps like `xim:python@latest` can resolve without falling back

// to unrelated remote index updates or system tools.

if (std::filesystem::exists(officialIndex / "pkgs", ec)) {

auto projectData = dotMcpp / ".xlings" / "data";

auto projectOfficial = projectData / "xim-pkgindex";

std::filesystem::create_directories(projectData, ec);

if (!std::filesystem::exists(projectOfficial, ec)) {

std::filesystem::create_directory_symlink(officialIndex, projectOfficial, ec);

if (ec) {

ec.clear();

std::filesystem::copy(

officialIndex,

projectOfficial,

std::filesystem::copy_options::recursive

| std::filesystem::copy_options::skip_existing,

ec);

}

}

}

return true;

}

// M5.5: persist [toolchain].default into config.toml without disturbing

// other fields. Naive: read text, replace/insert one line.

std::expected<void, ConfigError>

write_default_toolchain(const GlobalConfig& cfg, std::string_view spec) {

std::ifstream is(cfg.configFile);

if (!is) return std::unexpected(ConfigError{

std::format("cannot open '{}'", cfg.configFile.string())});

std::stringstream ss; ss << is.rdbuf();

std::string text = ss.str();

std::string line = std::format("default = \"{}\"\n", spec);

auto sectionPos = text.find("[toolchain]");

if (sectionPos == std::string::npos) {

// Append a [toolchain] block at end.

if (!text.empty() && text.back() != '\n') text += '\n';

text += std::format("\n[toolchain]\n{}", line);

} else {

// Locate existing `default = ...` within [toolchain]. If absent,

// insert just after the section header.

auto eol = text.find('\n', sectionPos);

if (eol == std::string::npos) eol = text.size();

auto bodyStart = (eol == text.size()) ? text.size() : eol + 1;

auto nextSec = text.find("\n[", bodyStart);

auto bodyEnd = (nextSec == std::string::npos) ? text.size() : nextSec;

auto body = std::string_view(text).substr(bodyStart, bodyEnd - bodyStart);

auto k = body.find("default");

if (k != std::string_view::npos) {

// replace that whole line

auto kAbs = bodyStart + k;

auto lineEnd = text.find('\n', kAbs);

if (lineEnd == std::string::npos) lineEnd = text.size();

text.replace(kAbs, lineEnd - kAbs + 1, line);

} else {

text.insert(bodyStart, line);

}

}

std::ofstream os(cfg.configFile);

if (!os) return std::unexpected(ConfigError{

std::format("cannot write '{}'", cfg.configFile.string())});

os << text;

return {};

}

} // namespace mcpp::config