Add native OBW editor POC with shared MCP session (by Codex)

This commit is contained in:
Codex committed 2026-10-22 21:41:10 +02:00
1 parent 6e5fa72ed5
commit bde8b10762
48 files changed
+5614 -1

No files matched your search

+326
View File
@@ -0,0 +1,326 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "editor/archive.hpp"
#include "content/digest.hpp"
#include <algorithm>
#include <chrono>
#include <cwctype>
#include <fstream>
#include <miniz.h>
#include <mutex>
#include <random>
#ifdef _WIN32
#define NOMINMAX
#include <windows.h>
#endif
namespace bmh::editor {
namespace {
constexpr uint64_t max_entry = 64ull * 1024 * 1024;
constexpr uint64_t max_total = 2ull * 1024 * 1024 * 1024;
constexpr size_t max_entries = 100000;
void publish(const fs::path &temporary, const fs::path &destination) {
#ifdef _WIN32
if (!MoveFileExW(temporary.c_str(), destination.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH))
throw Error("save_failed", {{"path", utf8(destination)}, {"system", GetLastError()}});
#else
std::error_code ec;
fs::rename(temporary, destination, ec);
if (ec)
throw Error("save_failed", {{"path", utf8(destination)}, {"system", ec.message()}});
#endif
}
struct Remove {
fs::path target;
~Remove() {
if (!target.empty()) {
std::error_code ec;
fs::remove_all(target, ec);
}
}
};
} // namespace
std::string utf8(const fs::path &value) {
const auto data = value.generic_u8string();
return {data.begin(), data.end()};
}
fs::path path(std::string_view value) { return fs::path(std::u8string(value.begin(), value.end())); }
bool safe_name(std::string_view value) {
if (value.empty() || value.front() == '/' || value.find('\\') != value.npos || value.find(':') != value.npos ||
value.find('\0') != value.npos || value.back() == '/')
return false;
const auto relative = path(value);
for (const auto &part : relative)
if (part == "." || part == ".." || part.empty())
return false;
return !relative.is_absolute();
}
std::string new_id(const std::string &prefix) {
static std::mutex lock;
static std::mt19937_64 random(std::random_device{}());
std::lock_guard guard(lock);
static const char *digits = "0123456789abcdef";
std::string result = prefix;
for (int n = 0; n < 2; ++n) {
auto number = random();
for (int i = 0; i < 16; ++i) {
result += digits[number & 15];
number >>= 4;
}
}
return result;
}
std::string folded(std::string value) {
// UTF-8 byte equality is retained; the small UI search additionally handles
// ASCII case without changing authored spelling or source identity.
for (char &c : value)
if (c >= 'A' && c <= 'Z')
c = char(c + ('a' - 'A'));
return value;
}
std::string read_file(const fs::path &file, uint64_t maximum) {
std::ifstream source(file, std::ios::binary);
if (!source)
throw Error("open_failed", {{"path", utf8(file)}});
source.seekg(0, std::ios::end);
auto size = source.tellg();
if (size < 0 || uint64_t(size) > maximum)
throw Error("size_limit", {{"path", utf8(file)}});
source.seekg(0);
std::string bytes(size_t(size), '\0');
source.read(bytes.data(), std::streamsize(bytes.size()));
if (!source && !bytes.empty())
throw Error("open_failed", {{"path", utf8(file)}});
return bytes;
}
void write_atomic(const fs::path &file, std::string_view data, bool overwrite) {
if (!overwrite && fs::exists(file))
throw Error("destination_exists");
if (fs::is_symlink(fs::symlink_status(file)))
throw Error("unsafe_path");
const auto parent = file.has_parent_path() ? file.parent_path() : fs::path(".");
if (!fs::is_directory(parent))
throw Error("output_parent_missing");
auto temporary = parent / new_id(".openbmh-editor-");
Remove cleanup{temporary};
{
std::ofstream output(temporary, std::ios::binary);
output.write(data.data(), std::streamsize(data.size()));
output.close();
if (!output)
throw Error("save_failed");
}
publish(temporary, file);
}
struct ArchiveStore::Impl {
fs::path cache;
fs::path root;
mutable std::ifstream input;
mutable mz_zip_archive zip{};
struct Item {
uint64_t size;
mz_uint index;
fs::path file;
};
std::map<std::string, Item> entries;
std::map<std::string, std::shared_ptr<const std::string>> changed;
mutable std::mutex mutex;
bool zip_open = false;
static size_t read_at(void *opaque, mz_uint64 offset, void *data, size_t count) {
auto &in = static_cast<Impl *>(opaque)->input;
in.clear();
in.seekg(std::streamoff(offset));
in.read(static_cast<char *>(data), std::streamsize(count));
return size_t(in.gcount());
}
~Impl() {
if (zip_open)
mz_zip_reader_end(&zip);
input.close();
if (!cache.empty()) {
std::error_code ec;
fs::remove_all(cache, ec);
}
}
};
ArchiveStore::ArchiveStore() : impl_(std::make_unique<Impl>()) {}
ArchiveStore::~ArchiveStore() = default;
std::shared_ptr<ArchiveStore> ArchiveStore::open(const fs::path &source) {
auto result = std::make_shared<ArchiveStore>();
auto &s = *result->impl_;
uint64_t total = 0;
auto add = [&](std::string name, Impl::Item item) {
if (!safe_name(name) || item.size > max_entry || total + item.size > max_total ||
s.entries.size() >= max_entries)
throw Error("archive_limit", {{"entry", name}});
if (!s.entries.emplace(name, std::move(item)).second)
throw Error("duplicate_entry", {{"entry", name}});
total += item.size;
};
if (fs::is_symlink(fs::symlink_status(source)))
throw Error("unsafe_path");
if (fs::is_directory(source)) {
const auto original = fs::canonical(source);
s.cache = fs::temp_directory_path() / new_id("openbmh-editor-");
s.root = s.cache / "world";
fs::create_directories(s.root);
for (const auto &entry : fs::recursive_directory_iterator(original)) {
if (entry.is_symlink())
throw Error("unsafe_path");
if (entry.is_regular_file()) {
const auto relative = entry.path().lexically_relative(original);
const auto snapshot = s.root / relative;
add(utf8(relative), {entry.file_size(), 0, snapshot});
fs::create_directories(snapshot.parent_path());
fs::copy_file(entry.path(), snapshot);
}
}
} else {
if (!fs::is_regular_file(source) || fs::file_size(source) > max_total)
throw Error("archive_limit");
s.cache = fs::temp_directory_path() / new_id("openbmh-editor-");
fs::create_directory(s.cache);
const auto snapshot = s.cache / "source.obw";
fs::copy_file(source, snapshot);
s.input.open(snapshot, std::ios::binary);
s.zip.m_pRead = Impl::read_at;
s.zip.m_pIO_opaque = &s;
if (!mz_zip_reader_init(&s.zip, fs::file_size(snapshot), 0))
throw Error("invalid_archive");
s.zip_open = true;
auto count = mz_zip_reader_get_num_files(&s.zip);
if (count > max_entries)
throw Error("archive_limit");
for (mz_uint index = 0; index < count; ++index) {
mz_zip_archive_file_stat stat{};
if (!mz_zip_reader_file_stat(&s.zip, index, &stat))
throw Error("invalid_archive");
if (stat.m_is_directory)
continue;
if (((stat.m_external_attr >> 16) & 0170000) == 0120000)
throw Error("unsafe_path");
if (stat.m_is_encrypted || !stat.m_is_supported)
throw Error("unsupported_archive");
add(stat.m_filename, {stat.m_uncomp_size, index, {}});
}
}
if (!s.entries.contains("manifest.json"))
throw Error("missing_manifest");
return result;
}
bool ArchiveStore::contains(const std::string &name) const {
return impl_->changed.contains(name) || impl_->entries.contains(name);
}
std::vector<std::string> ArchiveStore::names() const {
std::set<std::string> all;
for (const auto &[key, _] : impl_->entries)
all.insert(key);
for (const auto &[key, _] : impl_->changed)
all.insert(key);
return {all.begin(), all.end()};
}
uint64_t ArchiveStore::size(const std::string &name) const {
if (auto i = impl_->changed.find(name); i != impl_->changed.end())
return i->second->size();
if (auto i = impl_->entries.find(name); i != impl_->entries.end())
return i->second.size;
throw Error("missing_asset", {{"path", name}});
}
std::string ArchiveStore::read(const std::string &name) const {
if (auto i = impl_->changed.find(name); i != impl_->changed.end())
return *i->second;
const auto entry = impl_->entries.find(name);
if (entry == impl_->entries.end())
throw Error("missing_asset", {{"path", name}});
if (!entry->second.file.empty()) {
if (fs::is_symlink(fs::symlink_status(entry->second.file)))
throw Error("unsafe_path");
return read_file(entry->second.file, max_entry);
}
std::lock_guard guard(impl_->mutex);
std::string bytes(size_t(entry->second.size), '\0');
if (!mz_zip_reader_extract_to_mem(&impl_->zip, entry->second.index, bytes.data(), bytes.size(), 0))
throw Error("invalid_archive", {{"entry", name}});
return bytes;
}
void ArchiveStore::set(const std::string &name, std::shared_ptr<const std::string> bytes) {
if (!safe_name(name) || !bytes || bytes->size() > max_entry)
throw Error("unsafe_asset");
impl_->changed[name] = std::move(bytes);
}
std::shared_ptr<const std::string> ArchiveStore::overlay(const std::string &name) const {
auto i = impl_->changed.find(name);
return i == impl_->changed.end() ? nullptr : i->second;
}
void ArchiveStore::restore(const std::string &name, std::shared_ptr<const std::string> value) {
if (value)
set(name, std::move(value));
else
impl_->changed.erase(name);
}
void ArchiveStore::save(const fs::path &target, const std::map<std::string, std::string> &docs,
const std::set<std::string> &excluded) const {
if (target.extension() != ".obw")
throw Error("obw_only");
if (fs::is_symlink(fs::symlink_status(target)))
throw Error("unsafe_path");
auto parent = target.has_parent_path() ? target.parent_path() : fs::path(".");
if (!fs::is_directory(parent))
throw Error("output_parent_missing");
auto temporary = parent / new_id(".openbmh-editor-");
Remove cleanup{temporary};
std::ofstream output(temporary, std::ios::binary);
if (!output)
throw Error("save_failed");
mz_zip_archive writer{};
writer.m_pIO_opaque = &output;
writer.m_pWrite = [](void *opaque, mz_uint64 position, const void *data, size_t count) -> size_t {
auto &stream = *static_cast<std::ofstream *>(opaque);
stream.seekp(std::streamoff(position));
stream.write(static_cast<const char *>(data), std::streamsize(count));
return stream ? count : 0;
};
if (!mz_zip_writer_init_v2(&writer, 0, MZ_ZIP_FLAG_WRITE_ZIP64))
throw Error("save_failed");
struct Close {
mz_zip_archive *p;
~Close() { mz_zip_writer_end(p); }
} closer{&writer};
std::set<std::string> all;
for (auto &name : names())
all.insert(name);
for (auto &[name, _] : docs)
all.insert(name);
if (all.size() > max_entries)
throw Error("archive_limit");
uint64_t total = 0;
for (const auto &name : all) {
if (excluded.contains(name))
continue;
if (!safe_name(name))
throw Error("unsafe_path");
auto replacement = docs.find(name);
const auto bytes_size = replacement != docs.end() ? replacement->second.size() : size(name);
if (bytes_size > max_entry || (total += bytes_size) > max_total)
throw Error("archive_limit");
auto existing = impl_->entries.find(name);
if (replacement == docs.end() && !impl_->changed.contains(name) && impl_->zip_open &&
existing != impl_->entries.end()) {
std::lock_guard guard(impl_->mutex);
if (!mz_zip_writer_add_from_zip_reader(&writer, &impl_->zip, existing->second.index))
throw Error("save_failed");
} else {
auto bytes = replacement != docs.end() ? replacement->second : read(name);
const auto level = name.ends_with(".json") ? MZ_BEST_SPEED : MZ_NO_COMPRESSION;
if (!mz_zip_writer_add_mem(&writer, name.c_str(), bytes.data(), bytes.size(), level))
throw Error("save_failed");
}
}
if (!mz_zip_writer_finalize_archive(&writer))
throw Error("save_failed");
output.close();
if (!output)
throw Error("save_failed");
publish(temporary, target);
}
} // namespace bmh::editor