{

Binary,

Script,

Project,

Container,

Unknown

{

RunTargetKind kind{RunTargetKind::Unknown};

fs::path path{};

{

std::vector<std::string> args;

if (spec.find(';') == std::string::npos || spec.find('=') == std::string::npos)

{

args.push_back(spec);

args.push_back("--yes");

return args;

}

std::string git;

std::istringstream in(spec);

std::string part;

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

while (std::getline(in, part, ';'))

{

const auto eq = part.find('=');

if (eq == std::string::npos)

continue;

std::string key = part.substr(0, eq);

std::string value = part.substr(eq + 1);

if (key == "git" || key == "url")

git = value;

else

options.push_back({key, value});

}

if (!git.empty())

args.push_back(git);

for (const auto &[key, value] : options)

{

if (key == "tag" || key == "branch" || key == "rev" || key == "target" || key == "name" || key == "include" || key == "subdirectory")

{

args.push_back("--" + key);

args.push_back(value);

}

else if (key == "header_only" || key == "header-only")

{

if (value == "1" || value == "true" || value == "yes" || value == "on")

args.push_back("--header-only");

}

}

args.push_back("--yes");

return args;

{

std::error_code ec;

const fs::path old = fs::current_path(ec);

if (ec)

return 1;

fs::current_path(dir, ec);

if (ec)

return 1;

int rc = 0;

for (const std::string &dep : deps)

{

std::ostringstream muted;

std::streambuf *oldOut = std::cout.rdbuf(muted.rdbuf());

rc = vix::commands::InstallCommand::run(split_dep_spec(dep));

std::cout.rdbuf(oldOut);

if (rc != 0)

break;

}

fs::current_path(old, ec);

return rc;

{

std::error_code ec;

fs::path base = fs::temp_directory_path(ec);

if (ec)

base = fs::current_path();

const auto now = std::chrono::steady_clock::now().time_since_epoch().count();

fs::path dir = base / ("vix-run-deps-" + std::to_string(static_cast<long long>(now)));

fs::create_directories(dir, ec);

return dir;

{

if (!opt.singleCpp || opt.cppFile.empty())

{

error("--dep is supported for single C++ files");

return 2;

}

if (opt.saveTempDeps)

{

for (const std::string &dep : opt.tempDeps)

{

const int rc = vix::commands::InstallCommand::run(split_dep_spec(dep));

if (rc != 0)

return rc;

}

opt.tempDeps.clear();

return run_script_mode(opt);

}

const fs::path original = fs::absolute(opt.cppFile).lexically_normal();

const fs::path tempDir = make_temp_run_dep_dir();

const fs::path tempSource = tempDir / original.filename();

std::error_code ec;

fs::copy_file(original, tempSource, fs::copy_options::overwrite_existing, ec);

if (ec)

{

error("cannot prepare temporary run source: " + ec.message());

return 1;

}

{

std::ofstream app(tempDir / "vix.app", std::ios::binary | std::ios::trunc);

app << "name = \"vix-temp-run\"\n";

app << "type = \"executable\"\n";

app << "standard = \"c++20\"\n";

app << "sources = [\"" << original.filename().string() << "\"]\n";

}

const int installRc = install_temp_deps_in_dir(tempDir, opt.tempDeps);

if (installRc != 0)

{

fs::remove_all(tempDir, ec);

return installRc;

}

opt.cppFile = tempSource;

opt.tempDeps.clear();

const int rc = run_script_mode(opt);

fs::remove_all(tempDir, ec);

return rc;

{

auto is_ws = [](unsigned char c)

{ return c == ' ' || c == '\t' || c == '\n' || c == '\r'; };

while (!s.empty() && is_ws(static_cast<unsigned char>(s.back())))

s.pop_back();

std::size_t i = 0;

while (i < s.size() && is_ws(static_cast<unsigned char>(s[i])))

++i;

s.erase(0, i);

return s;

{

std::error_code ec;

const fs::path envFile = projectDir / ".env";

if (fs::exists(envFile, ec) && !ec)

return;

const fs::path envExample = projectDir / ".env.example";

if (!fs::exists(envExample, ec) || ec)

return;

if (!opt.envHint)

return;

hint(".env not found.");

step("cp .env.example .env");

{

std::string s = pkg;

const auto at = s.find('@');

if (at != std::string::npos)

s = s.substr(0, at);

const auto slash = s.find('/');

if (slash == std::string::npos)

return s;

return s.substr(0, slash) + "." + s.substr(slash + 1);

{

std::ifstream ifs(manifestFile);

std::vector<std::string> out;

if (!ifs)

return out;

bool inDeps = false;

std::string line;

while (std::getline(ifs, line))

{

line = trim_copy_local(line);

if (line.empty() || line[0] == '#')

continue;

if (line.size() >= 2 && line.front() == '[' && line.back() == ']')

{

const std::string sec = line.substr(1, line.size() - 2);

inDeps = (sec == "deps");

continue;

}

if (!inDeps)

continue;

if (line.rfind("packages", 0) != 0)

continue;

const auto eq = line.find('=');

if (eq == std::string::npos)

continue;

std::string rhs = trim_copy_local(line.substr(eq + 1));

const auto lb = rhs.find('[');

const auto rb = rhs.rfind(']');

if (lb == std::string::npos || rb == std::string::npos || rb <= lb)

continue;

std::string arr = rhs.substr(lb + 1, rb - lb - 1);

for (std::size_t i = 0; i < arr.size(); ++i)

{

if (arr[i] != '"')

continue;

const std::size_t j = arr.find('"', i + 1);

if (j == std::string::npos)

break;

out.push_back(arr.substr(i + 1, j - i - 1));

i = j;

}

}

return out;

const fs::path &projectDir,

const Options &opt,

fs::path &outExecutable)

{

namespace detail = vix::commands::RunCommand::detail;

std::string requestedTarget;

if (!opt.appName.empty() &&

opt.appName != projectDir.filename().string())

{

requestedTarget = opt.appName;

}

const fs::path buildDir = projectDir / "build-ninja";

std::ostringstream cmd;

#ifdef _WIN32

cmd << "cmd /C \"cd /D "

<< detail::quote(projectDir.string())

<< " && vix build --build-target ";

if (!requestedTarget.empty())

cmd << detail::quote(requestedTarget);

else

cmd << "all";

#else

cmd << "cd "

<< detail::quote(projectDir.string())

<< " && vix build --build-target ";

if (!requestedTarget.empty())

cmd << detail::quote(requestedTarget);

else

cmd << "all";

#endif

if (!opt.preset.empty())

cmd << " --preset " << detail::quote(opt.preset);

if (opt.jobs > 0)

cmd << " -j " << opt.jobs;

if (opt.verbose)

cmd << " -v";

else

cmd << " -q";

if (opt.clean)

cmd << " --clean";

if (opt.withSqlite)

cmd << " --with-sqlite";

if (opt.withMySql)

cmd << " --with-mysql";

#ifdef _WIN32

cmd << "\"";

#endif

const int rawCode =

detail::run_cmd_live_filtered(

cmd.str(),

"Building project");

const int buildExit =

detail::normalize_exit_code(rawCode);

if (buildExit == 130)

{

hint("Program interrupted by user.");

return 0;

}

if (buildExit != 0)

return buildExit;

auto exePath =

detail::resolve_runnable_executable(

buildDir,

requestedTarget);

if (!exePath)

{

if (!requestedTarget.empty())

{

error("Built executable not found for target: " + requestedTarget);

hint("Resolved build directory: " + buildDir.string());

detail::print_runnable_executable_candidates(buildDir);

return 1;

}

const auto candidates = detail::find_runnable_executables(buildDir, false);

if (candidates.empty())

{

error("No runnable executable found.");

hint("Resolved build directory: " + buildDir.string());

hint("The project may only build libraries, tests, or non-runnable targets.");

return 1;

}

error("Multiple runnable executables found.");

hint("Run one explicitly:");

for (const auto &p : candidates)

step(" vix run " + detail::runnable_executable_display_path(p));

return 1;

}

outExecutable = *exePath;

return 0;

{

const fs::path manifestDir = manifestFile.parent_path();

const fs::path depsRoot = manifestDir / ".vix" / "deps";

if (!fs::exists(depsRoot))

return;

const auto pkgs = parse_manifest_dep_packages_v1(manifestFile);

if (pkgs.empty())

return;

auto already_has_I = [&](const std::string &inc) -> bool

{

const std::string flag = "-I" + inc;

for (const auto &f : opt.scriptFlags)

{

if (f == flag)

return true;

if (f.rfind("-I", 0) == 0 && f.substr(2) == inc)

return true;

}

return false;

};

for (const auto &p : pkgs)

{

const std::string folder = to_dep_folder_name(p);

const fs::path inc = depsRoot / folder / "include";

std::error_code ec;

if (!fs::exists(inc, ec) || ec)

continue;

const std::string incStr = inc.string();

if (!already_has_I(incStr))

opt.scriptFlags.push_back("-I" + incStr);

}

{

if (!should_clear_terminal_now())

return;

std::cout << "\033[2J\033[H" << std::flush;

{

using Clock = std::chrono::steady_clock;

bool enabled = false;

int total = 0;

int current = 0;

std::string currentLabel;

Clock::time_point phaseStart{};

RunProgress(int totalSteps, bool enableUi)

: enabled(enableUi), total(totalSteps)

{

}

void phase_start(const std::string &label)

{

++current;

currentLabel = label;

phaseStart = Clock::now();

if (!enabled)

return;

std::cout << std::endl;

info("┏ [" + std::to_string(current) + "/" +

std::to_string(total) + "] " + label);

}

void phase_done(const std::string &label, const std::string &extra = {})

{

const auto end = Clock::now();

const auto ms =

std::chrono::duration_cast<std::chrono::milliseconds>(end - phaseStart).count();

if (!enabled)

return;

std::string msg =

"┗ [" + std::to_string(current) + "/" +

std::to_string(total) + "] " + label;

if (!extra.empty())

msg += " - " + extra;

std::ostringstream oss;

oss << std::fixed << std::setprecision(2)

<< (static_cast<double>(ms) / 1000.0);

msg += " (" + oss.str() + "s)";

success(msg);

}

{

#ifndef _WIN32

::setenv("VIX_STDOUT_MODE", "line", 1);

#endif

{

std::error_code ec{};

if (!fs::is_regular_file(p, ec) || ec)

return false;

#ifdef _WIN32

return p.extension() == ".exe";

#else

auto perms = fs::status(p, ec).permissions();

if (ec)

return false;

using pr = fs::perms;

return (perms & pr::owner_exec) != pr::none ||

(perms & pr::group_exec) != pr::none ||

(perms & pr::others_exec) != pr::none;

#endif

{

const std::string n = p.filename().string();

return n.find("_test") != std::string::npos ||

n.find("_tests") != std::string::npos ||

n.rfind("test_", 0) == 0;

{

std::error_code ec{};

if (!fs::exists(buildDir, ec) || ec)

return std::nullopt;

std::vector<fs::path> candidates;

for (auto it = fs::directory_iterator(buildDir, ec);

!ec && it != fs::directory_iterator();

++it)

{

const auto &p = it->path();

if (!is_executable_file(p))

continue;

if (!looks_like_test_binary(p))

continue;

candidates.push_back(p);

}

if (candidates.size() == 1)

return candidates.front();

return std::nullopt;

{

const char *cur = vix::utils::vix_getenv("VIX_MODE");

if (cur && *cur)

return;

#ifdef _WIN32

_putenv_s("VIX_MODE", opt.watch ? "dev" : "run");

#else

::setenv("VIX_MODE", opt.watch ? "dev" : "run", 1);

#endif

{

const bool enabled = opt.docs.has_value() && *opt.docs;

#ifdef _WIN32

_putenv_s("VIX_DOCS", enabled ? "1" : "0");

#else

::setenv("VIX_DOCS", enabled ? "1" : "0", 1);

#endif

{

if (!opt.cwd.empty())

opt.cwd = vix::commands::RunCommand::detail::normalize_cwd_if_needed(opt.cwd);

ensure_mode_env_for_run(opt);

enable_line_buffered_stdout_for_apps();

vix::commands::RunCommand::detail::apply_log_env(opt);

vix::cli::manifest::apply_env_pairs(opt.runEnv);

apply_docs_env(opt);

#ifndef _WIN32

::setenv("VIX_CLI_CLEAR", opt.clearMode.c_str(), 1);

#else

_putenv_s("VIX_CLI_CLEAR", opt.clearMode.c_str());

#endif

{

if (opt.singleCpp && opt.watch)

return vix::commands::RunCommand::detail::run_single_cpp_watch(opt);

if (opt.singleCpp)

{

int rc = vix::commands::RunCommand::detail::run_single_cpp(opt);

if (rc == 130)

{

hint("ℹ Program interrupted by user (SIGINT).");

return 0;

}

if (rc < 0)

return -rc;

return rc;

}

return 1;

const fs::path &buildDir,

const std::vector<std::string> &runArgs,

const std::string &cwd,

bool showUi)

{

auto testExe = find_single_test_binary(buildDir);

if (!testExe)

return -1;

if (showUi)

{

info("No main executable found. Detected library project; running test binary:");

step(testExe->string());

}

#ifdef _WIN32

std::string cmd = "\"" + testExe->string() + "\"";

cmd += vix::commands::RunCommand::detail::join_quoted_args_local(runArgs);

Options fakeOpt;

fakeOpt.cwd = cwd;

cmd = vix::commands::RunCommand::detail::wrap_with_cwd_if_needed(fakeOpt, cmd);

int raw = std::system(cmd.c_str());

int testExit = vix::commands::RunCommand::detail::normalize_exit_code(raw);

if (testExit == 130)

{

hint("ℹ Program interrupted by user (SIGINT).");

return 0;

}

if (testExit != 0)

{

error("Test execution failed (exit code " + std::to_string(testExit) + ").");

return testExit;

}

return 0;

#else

std::string testCmd = vix::commands::RunCommand::detail::quote(testExe->string());

testCmd += vix::commands::RunCommand::detail::join_quoted_args_local(runArgs);

Options fakeOpt;

fakeOpt.cwd = cwd;

testCmd = vix::commands::RunCommand::detail::wrap_with_cwd_if_needed(fakeOpt, testCmd);

const LiveRunResult tr =

vix::commands::RunCommand::detail::run_cmd_live_filtered_capture(

testCmd,

"",

true,

0,

false);

const int testExit = tr.exitCode;

if (testExit == 130)

{

hint("ℹ Program interrupted by user (SIGINT).");

return 0;

}

if (testExit != 0)

{

std::string log = tr.stderrText;

if (!tr.stdoutText.empty())

log += tr.stdoutText;

bool handled = false;

if (!log.empty())

{

const fs::path diagnosticPath{};

handled = vix::cli::errors::RawLogDetectors::handleRuntimeCrash(

log,

diagnosticPath,

"Test crashed");

if (!handled &&

vix::cli::errors::RawLogDetectors::handleKnownRunFailure(log, diagnosticPath))

{

handled = true;

}

if (!handled && !tr.printed_live)

std::cout << log << "\n";

}

if (!handled)

error("Test execution failed (exit code " + std::to_string(testExit) + ").");

return testExit;

}

return 0;

#endif

const fs::path &exePath,

const Options &opt,

const std::string &failureContext,

int timeoutSec,

bool instrumentedBinary = false)

{

#ifdef _WIN32

std::string runCmd = "\"" + exePath.string() + "\"";

runCmd += vix::commands::RunCommand::detail::join_quoted_args_local(opt.runArgs);

runCmd = vix::commands::RunCommand::detail::wrap_with_cwd_if_needed(opt, runCmd);

int raw = std::system(runCmd.c_str());

int runExit = vix::commands::RunCommand::detail::normalize_exit_code(raw);

if (runExit == 130)

{

hint("ℹ Program interrupted by user (SIGINT).");

return 0;

}

if (runExit != 0)

{

vix::commands::RunCommand::detail::handle_runtime_exit_code(

runExit,

failureContext,

false);

return runExit;

}

return 0;

#else

std::string runCmd = vix::commands::RunCommand::detail::quote(exePath.string());

runCmd += vix::commands::RunCommand::detail::join_quoted_args_local(opt.runArgs);

runCmd = vix::commands::RunCommand::detail::wrap_with_cwd_if_needed(opt, runCmd);

namespace replay = vix::commands::replay;

replay::ReplayRecorder recorder;

replay::ReplayRecorderConfig replayConfig{};

replayConfig.base_dir = fs::current_path();

replayConfig.cwd = fs::current_path();

replayConfig.project_dir = fs::current_path();

replayConfig.target_path = exePath;

replayConfig.mode = opt.watch ? replay::ReplayMode::Dev : replay::ReplayMode::Run;

replayConfig.target_kind = replay::ReplayTargetKind::Project;

replayConfig.command = opt.watch ? "vix dev" : "vix run";

replayConfig.resolved_command = runCmd;

replayConfig.app_args = opt.runArgs;

replayConfig.watch = opt.watch;

replayConfig.replayable = true;

std::string replayErr;

const bool replayEnabled =

opt.replay && recorder.begin(replayConfig, replayErr);

replay::ReplayCapture replayCapture;

if (replayEnabled)

replayCapture.attach(&recorder);

const bool useSanRuntime =

instrumentedBinary ||

vix::commands::RunCommand::detail::want_any_sanitizer(

opt.enableSanitizers,

opt.enableUbsanOnly,

opt.enableThreadSanitizer);

const LiveRunResult rr =

vix::commands::RunCommand::detail::run_cmd_live_filtered_capture(

runCmd,

"",

true,

timeoutSec,

useSanRuntime,

false,

replayEnabled ? &replayCapture : nullptr);

if (replayEnabled)

{

replay::ReplayProcessResult process =

replay::make_replay_process_result(

rr.exitCode,

rr.rawStatus,

rr.terminatedBySignal,

rr.termSignal);

replay::ReplayCapturedResult captured =

replay::make_replay_captured_result(

replayCapture.output(),

process);

replay::ReplayRecorderFinish finish =

replay::make_replay_finish_from_capture(captured);

std::string finishErr;

(void)recorder.finish(finish, finishErr);

}

int runExit = rr.exitCode;

if (runExit == 130)

{

hint("ℹ Program interrupted by user (SIGINT).");

return 0;

}

if (runExit != 0)

{

std::string log = rr.stderrText;

if (!rr.stdoutText.empty())

log += rr.stdoutText;

bool handled = false;

if (!log.empty())

{

const fs::path diagnosticPath =

opt.singleCpp

? opt.cppFile

: fs::path{};

handled = vix::cli::errors::RawLogDetectors::handleRuntimeCrash(

log,

diagnosticPath,

failureContext);

if (!handled &&

vix::cli::errors::RawLogDetectors::handleKnownRunFailure(log, diagnosticPath))

{

handled = true;

}

if (!handled && !rr.printed_live)

std::cout << log << "\n";

}

if (!handled)

error(failureContext + " (exit code " + std::to_string(runExit) + ").");

return runExit;

}

return 0;

#endif

const app::AppProjectResolveResult &resolved,

const Options &opt,

bool showUi)

{

using namespace vix::commands::RunCommand::detail;

const fs::path buildDir = resolved.userProjectDir / "build-ninja";

RunProgress progress(3, showUi);

{

std::error_code ec;

fs::create_directories(buildDir, ec);

if (ec)

{

error("Unable to create build directory: " + ec.message());

return 1;

}

}

const bool alreadyConfigured = has_cmake_cache(buildDir);

progress.phase_start("Configure project");

if (alreadyConfigured)

{

progress.phase_done("Configure project", "cache already present");

}

else

{

std::ostringstream oss;

#ifdef _WIN32

oss << "cmd /C \"cmake"

<< " --log-level=WARNING"

<< " -S " << quote(resolved.cmakeSourceDir.string())

<< " -B " << quote(buildDir.string())

<< " -G Ninja"

<< "\"";

#else

oss << "cmake"

<< " --log-level=WARNING"

<< " -S " << quote(resolved.cmakeSourceDir.string())

<< " -B " << quote(buildDir.string())

<< " -G Ninja";

#endif

const LiveRunResult cr = run_cmd_live_filtered_capture(

oss.str(),

"",

false,

0,

false);

const int code = cr.exitCode;

if (code != 0)

{

std::string log = cr.stderrText;

if (!cr.stdoutText.empty())

log += cr.stdoutText;

if (!log.empty())

{

const bool handled = vix::cli::ErrorHandler::printBuildErrors(

log,

resolved.cmakeListsPath,

"CMake configure failed");

if (!handled)

std::cout << log << "\n";

}

error("CMake configure failed.");

hint("Generated source directory: " + resolved.cmakeSourceDir.string());

hint("Build directory: " + buildDir.string());

return code != 0 ? code : 2;

}

progress.phase_done("Configure project", "completed");

}

progress.phase_start("Build project");