Jorijn van der Graaf
101471d81a
Jorijn: "all lenses off by default and opt in only". Config::Defaults() gives every lens run: false; a config that turns on none - a missing `lenses` key included - has the one problem that names the lenses, so config, freeze and run all stop on it; the template ships every lens off, init says to turn lenses on, and the "no lens runs" preflight names the cause. A consumer config without a `lenses` key now needs one, as the CI smoke test's does. Proven with the lens commit before it: the suite (26 passed), and the dry-run comparison recorded there.
485 lines
25 KiB
C++
485 lines
25 KiB
C++
// SPDX-License-Identifier: AGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
module Crafter.Review:Config_impl;
|
|
import :Config;
|
|
import :Json;
|
|
import :Text;
|
|
import :Core;
|
|
import :Plan;
|
|
import :Tools;
|
|
import :PgWire;
|
|
import :Process;
|
|
import :Platform;
|
|
import std;
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace Crafter::Review::Config {
|
|
namespace {
|
|
// Keys a consumer's config may still carry, with what replaced them.
|
|
struct Retired {
|
|
std::string_view section;
|
|
std::string_view key;
|
|
std::string why;
|
|
};
|
|
|
|
std::vector<Retired> RetiredKeys() {
|
|
return {{
|
|
"functional", "concurrency",
|
|
std::format("passes run as many at once as free memory allows, each at its environment's measured cost, and a pass that drives "
|
|
"the application holds a stack of its own (2026-10-22); for more of them at once bring up more stacks "
|
|
"(slots.*, `{} slots`)", Invocation()),
|
|
}};
|
|
}
|
|
|
|
std::string EnvironmentNames(std::string_view separator) {
|
|
std::vector<std::string> names;
|
|
for (const Plan::Environment& environment : Plan::Environments) names.emplace_back(environment.name);
|
|
return Dyn::Join(names, separator);
|
|
}
|
|
|
|
Json EnvironmentTable() {
|
|
Json table = Json::object();
|
|
for (const Plan::Environment& environment : Plan::Environments) table[std::string(environment.name)] = true;
|
|
return table;
|
|
}
|
|
|
|
bool AllStrings(const Json& list) {
|
|
return list.is_array() && std::ranges::all_of(list, [](const Json& item) { return item.is_string(); });
|
|
}
|
|
|
|
// ^(Bash\([^()]+:\*\)|mcp__[A-Za-z0-9_-]+(__[A-Za-z0-9_-]+)?)$; `$`
|
|
// also matches before a final newline.
|
|
bool IsToolEntry(std::string_view tool) {
|
|
std::string_view body = tool;
|
|
if (body.ends_with('\n')) body.remove_suffix(1);
|
|
if (body.starts_with("Bash(") && body.ends_with(":*)") && body.size() > 8) {
|
|
const std::string_view prefix = body.substr(5, body.size() - 8);
|
|
return !prefix.contains('(') && !prefix.contains(')');
|
|
}
|
|
if (body.starts_with("mcp__") && body.size() > 5) {
|
|
return std::ranges::all_of(body.substr(5), [](char c) {
|
|
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' || c == '-';
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// re.match(r'^https?://', text)
|
|
bool IsHttpUrl(std::string_view text) {
|
|
return text.starts_with("http://") || text.starts_with("https://");
|
|
}
|
|
|
|
// An integer or a float, not a bool.
|
|
bool IsRealNumber(const Json& value) {
|
|
return value.is_number();
|
|
}
|
|
|
|
bool Positive(const Json& value) {
|
|
return value.is_number_float() ? value.get<double>() > 0.0 : (value.is_number_unsigned() ? value.get<std::uint64_t>() > 0 : value.get<std::int64_t>() > 0);
|
|
}
|
|
|
|
std::vector<std::string> Merge(Json& destination, const Json& source, const std::string& path) {
|
|
std::vector<std::string> problems;
|
|
for (auto it = source.begin(); it != source.end(); ++it) {
|
|
const std::string& key = it.key();
|
|
if (!Dyn::Has(destination, key)) {
|
|
problems.push_back(std::format("unknown key {}{}", path, key));
|
|
continue;
|
|
}
|
|
Json& target = destination[key];
|
|
if (target.is_object() && it.value().is_object()) {
|
|
std::ranges::move(Merge(target, it.value(), std::format("{}{}.", path, key)), std::back_inserter(problems));
|
|
} else {
|
|
target = it.value();
|
|
}
|
|
}
|
|
return problems;
|
|
}
|
|
|
|
// The config's entry for the lens, else its default one.
|
|
const Json& LensEntry(const Json& config, std::string_view lensFile) {
|
|
static const Json defaults = Defaults()["lenses"];
|
|
const Json& lenses = Dyn::Get(config, "lenses");
|
|
const std::string name = Plan::LensName(lensFile);
|
|
const Json* entry = lenses.is_object() ? &Dyn::Get(lenses, name) : nullptr;
|
|
return entry && entry->is_object() ? *entry : defaults.at(name);
|
|
}
|
|
|
|
// A config or a slot file as JSON: the value, or the text that goes
|
|
// into the "not JSON (...)" problem.
|
|
std::variant<Json, std::string> LoadJson(const fs::path& path) {
|
|
try {
|
|
return Dyn::LoadJsonFile(path);
|
|
} catch (const std::exception& error) {
|
|
return std::string(error.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
Json Defaults() {
|
|
Json lenses = Json::object();
|
|
// Every lens is off until the repository's config turns it on
|
|
// (2026-10-31, Jorijn: "all lenses off by default and opt in only").
|
|
for (const Plan::Lens& lens : Plan::Lenses) lenses[Plan::LensName(lens.file)] = {{"run", false}, {"environment", lens.env}};
|
|
return {
|
|
// The integration branch a range is measured against (e.g.
|
|
// origin/dev): merge-base HEAD <base>.
|
|
{"base", nullptr},
|
|
// upstream: the push delta @{upstream}..HEAD, the base branch only
|
|
// when HEAD tracks nothing; base: always merge-base HEAD
|
|
// <base>..HEAD, the whole pull request.
|
|
{"rangeFrom", "upstream"},
|
|
// Author and committer emails the freeze accepts; null: the
|
|
// repository's `git config user.email`.
|
|
{"authors", nullptr},
|
|
// forbid | allow: Assisted-by / Co-Authored-By trailers in the
|
|
// range.
|
|
{"aiTrailers", "forbid"},
|
|
// An unsigned commit fails the freeze (else a warning).
|
|
{"requireSigned", false},
|
|
// Tracked paths the local stack rewrites in place while the lenses
|
|
// run.
|
|
{"allowDirty", Json::array()},
|
|
// The commands Gate 0 runs by hand, in order (documentation for the
|
|
// skill; the driver runs none of them).
|
|
{"gate0", Json::array()},
|
|
// Per lens: run (off until true: every lens is opt-in) and
|
|
// environment (Plan::Environments).
|
|
{"lenses", lenses},
|
|
// The database under test, for every lens whose environment
|
|
// reaches it. The URL reaches a db pass's broker, never a prompt,
|
|
// and the dump and the log show it with the password masked.
|
|
{"supabase", {{"dbUrl", "postgresql://postgres:postgres@127.0.0.1:54322/postgres"}, {"start", nullptr}, {"stop", nullptr}, {"notes", ""}}},
|
|
// Stacks side by side (2026-10-22): a pass that drives an
|
|
// application holds one of its own.
|
|
{"slots", {{"dir", nullptr}, {"start", nullptr}, {"stop", nullptr}, {"memMb", nullptr}, {"startMb", nullptr}}},
|
|
// The application under test, for every lens whose environment
|
|
// reaches one.
|
|
{"functional", {
|
|
{"appUrl", "http://localhost:8080"},
|
|
{"readyPath", "/"},
|
|
{"apiUrls", Json::array()},
|
|
{"start", nullptr},
|
|
{"stop", nullptr},
|
|
{"login", {{"fixtures", Json::array()}, {"notes", ""}}},
|
|
{"exclude", Json::array()},
|
|
{"extraTools", Json::array()},
|
|
{"mcp", {{"command", "npx"}, {"args", nullptr}}},
|
|
{"notes", ""},
|
|
}},
|
|
};
|
|
}
|
|
|
|
Loaded Load(const fs::path& repo, const fs::path& path) {
|
|
Loaded loaded{Defaults(), {}};
|
|
Json& config = loaded.config;
|
|
const fs::path p = path.empty() ? repo / ConfigFile : path;
|
|
std::vector<std::string> warnings;
|
|
if (fs::exists(p)) {
|
|
std::variant<Json, std::string> read = LoadJson(p);
|
|
if (std::holds_alternative<std::string>(read)) {
|
|
loaded.problems.push_back(std::format("{}: not JSON ({})", p.string(), std::get<std::string>(read)));
|
|
return loaded;
|
|
}
|
|
Json data = std::move(std::get<Json>(read));
|
|
if (!data.is_object()) {
|
|
loaded.problems.push_back(std::format("{}: the top level must be an object", p.string()));
|
|
return loaded;
|
|
}
|
|
for (const Retired& retired : RetiredKeys()) {
|
|
const Json& section = Dyn::Get(data, retired.section);
|
|
if (section.is_object() && Dyn::Has(section, retired.key)) {
|
|
warnings.push_back(std::format("{}.{} is no longer read - remove it from {}: {}", retired.section, retired.key, p.filename().string(), retired.why));
|
|
data[std::string(retired.section)].erase(std::string(retired.key));
|
|
}
|
|
}
|
|
loaded.problems = Merge(config, data, "");
|
|
} else if (!path.empty()) {
|
|
loaded.problems.push_back(std::format("{}: no such file", p.string()));
|
|
}
|
|
config["_path"] = fs::exists(p) ? Json(p.string()) : Json();
|
|
Json warningList = Json::array();
|
|
for (const std::string& warning : warnings) warningList.push_back(warning);
|
|
config["_warnings"] = std::move(warningList);
|
|
std::ranges::move(Validate(config), std::back_inserter(loaded.problems));
|
|
return loaded;
|
|
}
|
|
|
|
std::vector<std::string> Validate(const Json& config) {
|
|
std::vector<std::string> out;
|
|
const Json& trailers = Dyn::At(config, "aiTrailers");
|
|
if (trailers != "forbid" && trailers != "allow") out.emplace_back("aiTrailers must be 'forbid' or 'allow'");
|
|
const Json& rangeFrom = Dyn::At(config, "rangeFrom");
|
|
if (rangeFrom != "upstream" && rangeFrom != "base") out.emplace_back("rangeFrom must be 'upstream' or 'base'");
|
|
if (rangeFrom == "base" && !Dyn::Truthy(Dyn::At(config, "base"))) out.emplace_back("rangeFrom 'base' needs a base branch");
|
|
const Json& authors = Dyn::At(config, "authors");
|
|
if (!authors.is_null() && (!authors.is_array() || !std::ranges::all_of(authors, [](const Json& a) {
|
|
return a.is_string() && a.get_ref<const std::string&>().contains('@');
|
|
}))) {
|
|
out.emplace_back("authors must be null or a list of email addresses");
|
|
}
|
|
for (const std::string_view key : {"allowDirty", "gate0"}) {
|
|
if (!AllStrings(Dyn::At(config, key))) out.push_back(std::format("{} must be a list of strings", key));
|
|
}
|
|
const Json environments = EnvironmentTable();
|
|
Json lenses = Dyn::At(config, "lenses");
|
|
if (!lenses.is_object()) {
|
|
out.push_back(std::format("lenses must be an object: {{<lens name>: {{run: bool, environment: {}}}}}", EnvironmentNames("|")));
|
|
lenses = Json::object();
|
|
}
|
|
for (auto it = lenses.begin(); it != lenses.end(); ++it) {
|
|
const Json& entry = it.value();
|
|
if (!entry.is_object()) {
|
|
out.push_back(std::format("lenses.{} must be an object {{run: bool, environment: {}}}", it.key(), EnvironmentNames("|")));
|
|
continue;
|
|
}
|
|
if (!Dyn::Get(entry, "run").is_boolean()) out.push_back(std::format("lenses.{}.run must be true or false", it.key()));
|
|
if (!Dyn::In(Dyn::Get(entry, "environment"), environments)) out.push_back(std::format("lenses.{}.environment must be one of {}", it.key(), EnvironmentNames(", ")));
|
|
}
|
|
auto runs = [](const Json& entry) { return entry.is_object() && Dyn::Get(entry, "run") == true; };
|
|
// Every lens is off until the repository turns it on: a config that
|
|
// turns on none has nothing to run.
|
|
if (std::ranges::none_of(Plan::Lenses, [&](const Plan::Lens& lens) { return runs(Dyn::Get(lenses, Plan::LensName(lens.file))); })) {
|
|
std::vector<std::string> names;
|
|
for (const Plan::Lens& lens : Plan::Lenses) names.push_back(Plan::LensName(lens.file));
|
|
out.push_back(std::format("lenses: no lens is on - every lens is off until lenses.<name>.run = true turns it on for this repository ({})", Dyn::Join(names, ", ")));
|
|
}
|
|
for (const Plan::Lens& lens : Plan::Lenses) {
|
|
const Json& entry = Dyn::Get(lenses, Plan::LensName(lens.file));
|
|
if (!lens.empirical || !runs(entry)) continue;
|
|
const Json& name = Dyn::Get(entry, "environment");
|
|
if (!Dyn::In(name, environments)) continue;
|
|
if (!Plan::FindEnvironment(name.get_ref<const std::string&>())->app) {
|
|
std::vector<std::string> withApp;
|
|
for (const Plan::Environment& environment : Plan::Environments) {
|
|
if (environment.app) withApp.emplace_back(environment.name);
|
|
}
|
|
out.push_back(std::format("lenses.{}: an empirical lens needs an environment with an application under test ({}) - or turn it off", Plan::LensName(lens.file),
|
|
Dyn::Join(withApp, ", ")));
|
|
}
|
|
}
|
|
const Json& supabase = Dyn::At(config, "supabase");
|
|
if (!supabase.is_object()) {
|
|
out.emplace_back("supabase must be an object {dbUrl, start, stop, notes}");
|
|
} else {
|
|
if (const std::optional<std::string> problem = PgWire::CheckUrl(Dyn::Get(supabase, "dbUrl"))) out.push_back(std::format("supabase.dbUrl: {}", *problem));
|
|
for (const std::string_view key : {"start", "stop"}) {
|
|
const Json& value = Dyn::Get(supabase, key);
|
|
if (!value.is_null() && !value.is_string()) out.push_back(std::format("supabase.{} must be null or a command line", key));
|
|
}
|
|
if (!Dyn::Get(supabase, "notes").is_string()) out.emplace_back("supabase.notes must be text");
|
|
}
|
|
const Json& functional = Dyn::At(config, "functional");
|
|
if (!functional.is_object()) {
|
|
out.emplace_back("functional must be an object");
|
|
return out;
|
|
}
|
|
// The application's URL matters only to a lens that drives it.
|
|
const bool drivesApp = std::ranges::any_of(lenses, [&](const Json& entry) {
|
|
if (!runs(entry)) return false;
|
|
const Json& name = Dyn::Get(entry, "environment");
|
|
if (name.is_array() || name.is_object()) throw Dyn::Error("TypeError", std::format("unhashable type: '{}'", Dyn::TypeName(name)));
|
|
const Plan::Environment* environment = name.is_string() ? Plan::FindEnvironment(name.get_ref<const std::string&>()) : nullptr;
|
|
return environment && environment->app;
|
|
});
|
|
if (drivesApp && !IsHttpUrl(Dyn::StrOr(Dyn::At(functional, "appUrl"), ""))) out.emplace_back("functional.appUrl must be an http(s) URL");
|
|
if (!AllStrings(Dyn::At(functional, "exclude"))) out.emplace_back("functional.exclude must be a list of globs");
|
|
const Json& extraTools = Dyn::At(functional, "extraTools");
|
|
if (!extraTools.is_array() || !std::ranges::all_of(extraTools, [](const Json& x) { return x.is_string() && IsToolEntry(x.get_ref<const std::string&>()); })) {
|
|
out.emplace_back("functional.extraTools entries must be Bash(<prefix>:*) or mcp__<server>[__<tool>]");
|
|
} else {
|
|
std::vector<std::string> dead;
|
|
for (const Json& tool : extraTools) {
|
|
if (Tools::Denied(tool.get_ref<const std::string&>())) dead.push_back(tool.get<std::string>());
|
|
}
|
|
if (!dead.empty()) {
|
|
out.push_back(std::format("functional.extraTools: {} - denied to every pass (pool.DENY wins over an allowlist); "
|
|
"a lens reaches the database through the supabase environment, every call rolled back", Dyn::Join(dead, ", ")));
|
|
}
|
|
}
|
|
const Json& login = Dyn::At(functional, "login");
|
|
if (!login.is_object() || !(Dyn::Has(login, "fixtures") ? Dyn::At(login, "fixtures").is_array() : true)) out.emplace_back("functional.login must be {fixtures: [paths], notes: text}");
|
|
const Json& slots = Dyn::At(config, "slots");
|
|
if (!slots.is_object()) {
|
|
out.emplace_back("slots must be an object {dir, start, stop, memMb, startMb}");
|
|
} else if (!Dyn::Get(slots, "dir").is_null()) {
|
|
const Json& dir = Dyn::At(slots, "dir");
|
|
bool bad = !dir.is_string();
|
|
if (!bad) {
|
|
const std::string& d = dir.get_ref<const std::string&>();
|
|
const std::vector<std::string> parts = Dyn::Split(Dyn::Replace(d, "\\", "/"), "/");
|
|
bad = Dyn::Strip(d).empty() || d.starts_with('/') || std::ranges::contains(parts, std::string(".."));
|
|
}
|
|
if (bad) out.emplace_back("slots.dir must be null or a directory inside the repository (a relative path)");
|
|
for (const std::string_view key : {"start", "stop"}) {
|
|
const Json& value = Dyn::Get(slots, key);
|
|
if (!value.is_null() && (!value.is_string() || !value.get_ref<const std::string&>().contains("{n}"))) {
|
|
out.push_back(std::format("slots.{} must be null or a command line with {{n}}, the slot number", key));
|
|
}
|
|
}
|
|
const Json& memMb = Dyn::Get(slots, "memMb");
|
|
if (!IsRealNumber(memMb) || !Positive(memMb)) {
|
|
out.push_back(std::format("slots.memMb must be the measured memory of one slot in MB (a number > 0): `{} slots` sizes the slots by it", Invocation()));
|
|
}
|
|
const Json& startMb = Dyn::Get(slots, "startMb");
|
|
if (!startMb.is_null() && (!IsRealNumber(startMb) || !Positive(startMb))) {
|
|
out.emplace_back("slots.startMb must be null or the measured peak of one slot coming up in MB (a number > 0)");
|
|
}
|
|
}
|
|
const Json& args = Dyn::Get(Dyn::At(functional, "mcp"), "args");
|
|
if (!args.is_null() && !AllStrings(args)) out.emplace_back("functional.mcp.args must be null or a list of strings");
|
|
// A path found on the host, such as /usr/bin/npx, is not there inside
|
|
// the Flatpak, whose /usr is the Sdk's.
|
|
const Json& command = Dyn::Get(Dyn::At(functional, "mcp"), "command");
|
|
if (command.is_string() && command.get<std::string>().starts_with('/')) {
|
|
std::error_code error;
|
|
const fs::path file(command.get<std::string>());
|
|
const bool executable = fs::is_regular_file(file, error) && (fs::status(file, error).permissions() & (fs::perms::owner_exec | fs::perms::group_exec | fs::perms::others_exec)) != fs::perms::none;
|
|
if (!executable) {
|
|
out.emplace_back(std::format("functional.mcp.command {} is no program here{}", Dyn::Repr(command.get<std::string>()),
|
|
Platform::InSandbox() ? " (inside the Flatpak /usr is the Sdk's: name it `npx`, the bundled one)" : ""));
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
Json Redacted(const Json& config) {
|
|
Json copy = Json::object();
|
|
for (auto it = config.begin(); it != config.end(); ++it) {
|
|
if (!it.key().starts_with('_')) copy[it.key()] = it.value();
|
|
}
|
|
if (Dyn::Get(copy, "supabase").is_object() && Dyn::Get(copy["supabase"], "dbUrl").is_string()) {
|
|
copy["supabase"]["dbUrl"] = PgWire::Redact(copy["supabase"]["dbUrl"].get<std::string>());
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
std::string GitUserEmail(const fs::path& repo) {
|
|
const Process::Captured run = Process::Run({"git", "-C", repo.string(), "config", "user.email"});
|
|
return run.returnCode == 0 ? Dyn::Strip(Dyn::UniversalNewlines(Dyn::DecodeReplace(run.out))) : std::string();
|
|
}
|
|
|
|
std::vector<std::string> Authors(const Json& config, const fs::path& repo) {
|
|
const Json& authors = Dyn::Get(config, "authors");
|
|
if (Dyn::Truthy(authors)) {
|
|
std::vector<std::string> out;
|
|
for (const Json& author : authors) out.push_back(Dyn::Str(author));
|
|
return out;
|
|
}
|
|
const std::string email = GitUserEmail(repo);
|
|
if (email.empty()) return {};
|
|
return {email};
|
|
}
|
|
|
|
std::vector<std::string> LensesOff(const Json& config) {
|
|
std::vector<std::string> out;
|
|
for (const Plan::Lens& lens : Plan::Lenses) {
|
|
if (Dyn::Get(LensEntry(config, lens.file), "run") == false) out.emplace_back(lens.file);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
Json Environments(const Json& config) {
|
|
Json out = Json::object();
|
|
for (const Plan::Lens& lens : Plan::Lenses) {
|
|
const Json& entry = LensEntry(config, lens.file);
|
|
out[std::string(lens.file)] = Dyn::Has(entry, "environment") ? Dyn::At(entry, "environment") : Json("none");
|
|
}
|
|
return out;
|
|
}
|
|
|
|
Slots SlotStacks(const Json& config, const fs::path& repo) {
|
|
Slots slots;
|
|
const Json& dir = Dyn::Get(Dyn::Or(Dyn::Get(config, "slots"), Dyn::EmptyDict()), "dir");
|
|
if (!Dyn::Truthy(dir) || !fs::is_directory(repo / dir.get<std::string>())) return slots;
|
|
const std::string d = dir.get<std::string>();
|
|
std::vector<std::string> names;
|
|
for (const fs::directory_entry& entry : fs::directory_iterator(repo / d)) names.push_back(entry.path().filename().string());
|
|
std::ranges::stable_sort(names, {}, [](const std::string& name) { return Dyn::Natural(name); });
|
|
for (const std::string& n : names) {
|
|
const fs::path file = repo / d / n / SlotFile;
|
|
if (!fs::is_regular_file(file)) continue;
|
|
const std::string rel = Dyn::JoinPath(Dyn::JoinPath(d, n), SlotFile);
|
|
std::variant<Json, std::string> read = LoadJson(file);
|
|
if (std::holds_alternative<std::string>(read)) {
|
|
slots.problems.push_back(std::format("{}: not JSON ({})", rel, std::get<std::string>(read)));
|
|
continue;
|
|
}
|
|
const Json& s = std::get<Json>(read);
|
|
if (!s.is_object() || !IsHttpUrl(Dyn::StrOr(Dyn::Get(s, "appUrl"), ""))) {
|
|
slots.problems.push_back(std::format("{}: no appUrl", rel));
|
|
continue;
|
|
}
|
|
const Json& api = Dyn::Or(Dyn::Get(s, "apiUrls"), Dyn::EmptyList());
|
|
if (!AllStrings(api)) {
|
|
slots.problems.push_back(std::format("{}: apiUrls must be a list of URLs", rel));
|
|
continue;
|
|
}
|
|
const Json& db = Dyn::Get(s, "dbUrl");
|
|
if (!db.is_null()) {
|
|
if (const std::optional<std::string> problem = PgWire::CheckUrl(db)) {
|
|
slots.problems.push_back(std::format("{}: dbUrl: {}", rel, *problem));
|
|
continue;
|
|
}
|
|
}
|
|
const Json& login = Dyn::Get(s, "login");
|
|
if (!login.is_null() && (!login.is_string() || !fs::exists(repo / login.get<std::string>()))) {
|
|
slots.problems.push_back(std::format("{}: login {} is not a file", rel, Dyn::ReprValue(login)));
|
|
continue;
|
|
}
|
|
slots.stacks.push_back({
|
|
{"id", std::format("slot {}", n)},
|
|
{"appUrl", Dyn::RStrip(Dyn::At(s, "appUrl").get<std::string>(), "/")},
|
|
{"apiUrls", api},
|
|
{"dbUrl", db},
|
|
{"login", login},
|
|
{"slot", true},
|
|
});
|
|
}
|
|
return slots;
|
|
}
|
|
|
|
std::vector<std::string> SlotCommands(const Json& config, std::string_view which, std::span<const std::int64_t> slots) {
|
|
const Json& command = Dyn::Get(Dyn::Or(Dyn::Get(config, "slots"), Dyn::EmptyDict()), which);
|
|
if (!Dyn::Truthy(command)) return {};
|
|
std::vector<std::string> out;
|
|
for (const std::int64_t n : slots) out.push_back(Dyn::Replace(command.get<std::string>(), "{n}", std::to_string(n)));
|
|
return out;
|
|
}
|
|
|
|
std::optional<std::string> LoginFixture(const Json& config, const fs::path& repo) {
|
|
const Json& login = Dyn::Or(Dyn::Get(Dyn::At(config, "functional"), "login"), Dyn::EmptyDict());
|
|
for (const Json& fixture : Dyn::Or(Dyn::Get(login, "fixtures"), Dyn::EmptyList())) {
|
|
if (fs::exists(repo / fixture.get<std::string>())) return fixture.get<std::string>();
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
Json Example() {
|
|
Json example = Defaults();
|
|
example["base"] = "origin/main";
|
|
example["authors"] = {"you@example.com"};
|
|
example["aiTrailers"] = "forbid";
|
|
example["gate0"] = {"make check"};
|
|
Json& functional = example["functional"];
|
|
functional["appUrl"] = "http://localhost:8080";
|
|
functional["start"] = "make run";
|
|
functional["stop"] = "make stop";
|
|
functional["login"] = {{"fixtures", {".local-stack/test-user.json"}}, {"notes", "the fixture holds a TOTP-verified login"}};
|
|
functional["exclude"] = {"**/*.test.*", "**/*.spec.*", "docs/**", ".github/**", "*.md"};
|
|
return example;
|
|
}
|
|
|
|
std::int32_t Main(const fs::path& repo, const fs::path& path) {
|
|
const Loaded loaded = Load(repo, path);
|
|
Json shown = Redacted(loaded.config);
|
|
// The database password masked, as in the dump.
|
|
shown["_path"] = Dyn::Get(loaded.config, "_path");
|
|
std::println("{}", DumpFile(shown));
|
|
for (const Json& warning : Dyn::Or(Dyn::Get(loaded.config, "_warnings"), Dyn::EmptyList())) std::println("warning: {}", Dyn::Str(warning));
|
|
for (const std::string& problem : loaded.problems) std::println("problem: {}", problem);
|
|
return loaded.problems.empty() ? 0 : 1;
|
|
}
|
|
}
|