afterpresets 0.1.0 → 0.3.0

package/native-runtime/src/runtime.cpp

@@ -0,0 +1,473 @@
+// C API, worker thread and log for ap_native. See include/ap_native.h.
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <cstring>
+#include <deque>
+#include <mutex>
+#include <regex>
+#include <thread>
+
+#ifdef __APPLE__
+#include <pthread.h>
+#endif
+
+#include "ap_native.h"
+#include "dialog.hpp"
+#include "engine.hpp"
+#include "fsutil.hpp"
+#include "util.hpp"
+
+namespace apn {
+
+// ------------------------------------------------------------------ log
+//
+// Size-capped, rotating, thread-safe. ap_log never blocks: it appends to an
+// in-memory queue with try_lock (render threads) and drops the line if the
+// queue is busy or full; the worker thread writes the file. Tokens (apl_...)
+// and URL query strings (signed download URLs) are scrubbed before writing.
+class Logger {
+public:
+    static constexpr size_t MAX_QUEUE = 512;
+    static constexpr uint64_t MAX_BYTES = 1024 * 1024;
+
+    void open(const std::string &path) { path_ = path; }
+    const std::string &path() const { return path_; }
+
+    void push(int level, const std::string &message, int64_t now_ms, bool may_block) {
+        if (path_.empty()) return;
+        std::unique_lock<std::mutex> l(mu_, std::defer_lock);
+        if (may_block) l.lock();
+        else if (!l.try_lock()) { dropped_.fetch_add(1); return; }
+        if (queue_.size() >= MAX_QUEUE) { dropped_.fetch_add(1); return; }
+        static const char *names[] = {"debug", "info", "warn", "error"};
+        queue_.push_back(format_iso8601(now_ms) + " [" + names[std::clamp(level, 0, 3)] + "] " + message);
+    }
+
+    bool pending() {
+        std::lock_guard<std::mutex> l(mu_);
+        return !queue_.empty();
+    }
+
+    void flush() {
+        std::deque<std::string> lines;
+        {
+            std::lock_guard<std::mutex> l(mu_);
+            lines.swap(queue_);
+        }
+        unsigned dropped = dropped_.exchange(0);
+        if (lines.empty() && !dropped) return;
+        std::string text;
+        for (auto &line : lines) text += scrub(line) + "\n";
+        if (dropped) text += "(" + std::to_string(dropped) + " log lines dropped)\n";
+        fsu::mkdirs(fsu::parent(path_));
+        auto st = fsu::stamp(path_);
+        if (st && st->size > MAX_BYTES) {
+            // Over the cap: keep one previous file.
+            fsu::remove_file(path_ + ".1");
+            fsu::rename(path_, path_ + ".1");
+        }
+        FILE *f = std::fopen(path_.c_str(), "ab");
+        if (!f) return;
+        std::fwrite(text.data(), 1, text.size(), f);
+        std::fclose(f);
+    }
+
+    static std::string scrub(const std::string &line) {
+        static const std::regex token("apl_[A-Za-z0-9_-]{8,}");
+        static const std::regex query("(https?://[^\\s?#]+)\\?[^\\s]*");
+        return std::regex_replace(std::regex_replace(line, token, "apl_***"), query, "$1?***");
+    }
+
+private:
+    std::string path_;
+    std::mutex mu_;
+    std::deque<std::string> queue_;
+    std::atomic<unsigned> dropped_{0};
+};
+
+std::string default_log_dir(const std::string &data_root_override) {
+    if (!data_root_override.empty()) return fsu::join(fsu::join(data_root_override, "AfterPresets"), "Logs");
+#ifdef _WIN32
+    std::string root = platform_data_root();  // %LOCALAPPDATA%
+    return root.empty() ? "" : fsu::join(fsu::join(root, "AfterPresets"), "Logs");
+#else
+    const char *home = getenv("HOME");
+    return home && *home ? std::string(home) + "/Library/Logs/AfterPresets" : "";
+#endif
+}
+
+// ------------------------------------------------------------------ worker
+
+struct Cmd {
+    enum Kind { Validate, ValidateBehind, SignIn, CancelSignIn, OpenPage, Retry, SignOut, CheckUpdate, Download,
+                MarkApplied } kind;
+    std::string arg;
+};
+
+struct Shared {
+    Settings settings;
+    Env env;
+    std::unique_ptr<Engine> engine;
+    Logger logger;
+
+    std::atomic<int> unlocked{0};
+    std::atomic<int> status{(int)Status::Checking};
+    std::atomic<uint64_t> generation{0};
+    std::mutex view_mu;
+    LicenseView license;
+    UpdateView update;
+    std::string notice;
+
+    std::mutex q_mu;
+    std::condition_variable cv;       // work arrived / stop
+    std::condition_variable idle_cv;  // worker went idle / finished
+    std::deque<Cmd> queue;
+    bool stop = false;
+    bool busy = false;
+    bool finished = false;
+    std::atomic<bool> cancel{false};
+
+    void (*on_change)(void *) = nullptr;
+    void *user = nullptr;
+
+    void publish() {
+        {
+            std::lock_guard<std::mutex> l(view_mu);
+            license = engine->license();
+            update = engine->update();
+            notice = engine->notice();
+        }
+        status.store((int)engine->license().status);
+        unlocked.store(engine->unlocked() ? 1 : 0);
+        generation.fetch_add(1);
+        if (on_change) on_change(user);
+    }
+
+    void post(Cmd cmd) {
+        {
+            std::lock_guard<std::mutex> l(q_mu);
+            if (stop) return;
+            queue.push_back(std::move(cmd));
+        }
+        cv.notify_all();
+    }
+};
+
+void run(Shared &sh, const Cmd &cmd) {
+    Engine &e = *sh.engine;
+    switch (cmd.kind) {
+        case Cmd::Validate: e.validate_stored(); break;
+        case Cmd::ValidateBehind: e.validate_behind(); break;
+        case Cmd::SignIn: e.sign_in(); break;
+        case Cmd::CancelSignIn: e.cancel_sign_in(); break;
+        case Cmd::OpenPage: e.open_sign_in_page(); break;
+        case Cmd::Retry: e.validate_stored(); break;
+        case Cmd::SignOut: e.sign_out(); break;
+        case Cmd::CheckUpdate: e.check_updates(false); break;
+        case Cmd::Download: e.download_update(); break;
+        case Cmd::MarkApplied: e.mark_applied(cmd.arg); break;
+    }
+}
+
+void worker_main(std::shared_ptr<Shared> sh) {
+#ifdef __APPLE__
+    pthread_setname_np("AfterPresets runtime");
+#endif
+    cleanup_install_leftovers(sh->settings);
+    for (;;) {
+        std::optional<Cmd> cmd;
+        {
+            std::unique_lock<std::mutex> l(sh->q_mu);
+            if (sh->queue.empty() && !sh->stop) {
+                int64_t next = sh->engine->next_wake();
+                int64_t delay = next == INT64_MAX ? 60000 : next - sh->env.now_ms();
+                delay = std::clamp<int64_t>(delay, 0, 60000);
+                if (sh->logger.pending()) delay = std::min<int64_t>(delay, 250);
+                if (delay > 0) {
+                    sh->cv.wait_for(l, std::chrono::milliseconds(delay), [&] { return sh->stop || !sh->queue.empty(); });
+                }
+            }
+            if (sh->stop) break;
+            if (!sh->queue.empty()) {
+                cmd = std::move(sh->queue.front());
+                sh->queue.pop_front();
+            }
+            sh->busy = true;
+        }
+        if (cmd) run(*sh, *cmd);
+        sh->engine->tick();
+        sh->logger.flush();
+        {
+            std::lock_guard<std::mutex> l(sh->q_mu);
+            sh->busy = false;
+        }
+        sh->idle_cv.notify_all();
+    }
+    sh->logger.flush();
+    {
+        std::lock_guard<std::mutex> l(sh->q_mu);
+        sh->finished = true;
+        sh->busy = false;
+    }
+    sh->idle_cv.notify_all();
+}
+
+void copy_text(char *dst, size_t cap, const std::string &src) {
+    if (!cap) return;
+    size_t n = std::min(src.size(), cap - 1);
+    // Do not cut a UTF-8 sequence in half.
+    while (n > 0 && n < src.size() && ((unsigned char)src[n] & 0xC0) == 0x80) n--;
+    std::memcpy(dst, src.data(), n);
+    dst[n] = '\0';
+}
+
+}  // namespace apn
+
+using namespace apn;
+
+struct ap_runtime {
+    std::shared_ptr<Shared> sh;
+    std::thread worker;
+};
+
+extern "C" {
+
+void ap_config_defaults(ap_config *c) {
+    if (!c) return;
+    std::memset(c, 0, sizeof *c);
+    c->license_enabled = 1;
+    c->offline_grace_days = 0;
+    c->check_in_background = 1;
+    c->update_mode = AP_UPDATES_BACKGROUND;
+    c->apply_when_staged = 1;
+    c->channel = "production";
+}
+
+ap_runtime *ap_init(const ap_config *c) {
+    if (!c || !c->bundle_id || !c->version || !c->api_base) return nullptr;
+    Settings s;
+    s.bundle_id = c->bundle_id;
+    s.version = c->version;
+    s.api_base = c->api_base;
+    if (!is_bundle_id(s.bundle_id) || !is_semver(s.version) || !is_allowed_api_base(s.api_base)) return nullptr;
+    if (c->public_key && *c->public_key) {
+        s.public_key = parse_public_key(c->public_key);
+        if (!s.public_key) return nullptr;  // a malformed key is a build mistake: fail closed
+    }
+    s.product_url = c->product_url ? c->product_url : "";
+    s.manage_devices_url = c->manage_devices_url ? c->manage_devices_url : "";
+    s.channel = c->channel && std::strcmp(c->channel, "test") == 0 ? "test" : "production";
+    s.license_enabled = c->license_enabled != 0;
+    s.grace_days = std::clamp(c->offline_grace_days, 0, 30);
+    s.background = c->check_in_background != 0;
+    switch (c->update_mode) {
+        case AP_UPDATES_OFF: s.update_mode = UpdateMode::Off; break;
+        case AP_UPDATES_MANUAL: s.update_mode = UpdateMode::Manual; break;
+        case AP_UPDATES_NOTIFY: s.update_mode = UpdateMode::Notify; break;
+        default: s.update_mode = UpdateMode::Background; break;
+    }
+    s.dev = c->dev != 0;
+    s.apply_when_staged = c->apply_when_staged != 0;
+    s.os = platform_os();
+    s.arch = platform_arch();
+    s.runtime_version = AP_NATIVE_VERSION;
+    std::string binary = platform_self_binary_path();
+    s.install_dir = c->install_dir ? c->install_dir : find_install_dir(binary, s.bundle_id);
+
+    auto sh = std::make_shared<Shared>();
+    sh->on_change = c->on_change;
+    sh->user = c->user;
+    Env env = platform_env(std::string("afterpresets-native/") + AP_NATIVE_VERSION + " (" + s.os + "; " + s.arch + ")");
+    if (c->data_root && *c->data_root) env.data_root = c->data_root;
+    if (env.data_root.empty()) return nullptr;
+    std::string log_dir = default_log_dir(c->data_root ? c->data_root : "");
+    if (!log_dir.empty()) sh->logger.open(fsu::join(log_dir, s.bundle_id + ".log"));
+    Shared *raw = sh.get();
+    auto user_log = c->log;
+    void *user = c->user;
+    env.log = [raw, user_log, user](int level, const std::string &m) {
+        raw->logger.push(level, m, raw->env.now_ms ? raw->env.now_ms() : 0, true);
+        if (user_log) user_log(user, level, Logger::scrub(m).c_str());
+    };
+    sh->settings = s;
+    sh->env = env;
+    sh->engine = std::make_unique<Engine>(s, env, [raw] { raw->publish(); });
+    sh->engine->set_cancel(&sh->cancel);
+
+    // The line an agent greps for to prove which build After Effects loaded.
+    env.log(1, "start " + s.bundle_id + " " + s.version + " build=" + (c->build_id ? c->build_id : "unknown") +
+                   " runtime=" AP_NATIVE_VERSION " os=" + s.os + " arch=" + s.arch +
+                   " license=" + (s.license_enabled ? "on" : "off") + " updates=" + std::to_string((int)c->update_mode) +
+                   " installed=" + (s.install_dir.empty() ? "no" : "yes") + " binary=" + binary);
+
+    // Decide from disk before the first render (no network).
+    Engine::Launch launch = sh->engine->launch_local();
+    sh->publish();
+    if (launch == Engine::Launch::Validate) sh->queue.push_back({Cmd::Validate, ""});
+    if (launch == Engine::Launch::ValidateBehind) sh->queue.push_back({Cmd::ValidateBehind, ""});
+
+    auto *rt = new ap_runtime();
+    rt->sh = sh;
+    rt->worker = std::thread(worker_main, sh);
+    return rt;
+}
+
+void ap_shutdown(ap_runtime *rt) {
+    if (!rt) return;
+    auto sh = rt->sh;
+    {
+        std::lock_guard<std::mutex> l(sh->q_mu);
+        sh->stop = true;
+        sh->cancel.store(true);
+    }
+    sh->cv.notify_all();
+    bool done;
+    {
+        std::unique_lock<std::mutex> l(sh->q_mu);
+        done = sh->idle_cv.wait_for(l, std::chrono::seconds(3), [&] { return sh->finished; });
+    }
+    if (done) rt->worker.join();
+    else rt->worker.detach();  // the thread holds its own reference to the shared state
+    delete rt;
+}
+
+int ap_is_unlocked(const ap_runtime *rt) { return rt ? rt->sh->unlocked.load(std::memory_order_acquire) : 0; }
+
+ap_status ap_status_get(const ap_runtime *rt) {
+    return rt ? (ap_status)rt->sh->status.load(std::memory_order_acquire) : AP_STATUS_ERROR;
+}
+
+uint64_t ap_generation(const ap_runtime *rt) { return rt ? rt->sh->generation.load(std::memory_order_acquire) : 0; }
+
+void ap_get_state(ap_runtime *rt, ap_state *out) {
+    if (!out) return;
+    std::memset(out, 0, sizeof *out);
+    if (!rt) { out->status = AP_STATUS_ERROR; return; }
+    std::lock_guard<std::mutex> l(rt->sh->view_mu);
+    const LicenseView &v = rt->sh->license;
+    out->status = (ap_status)v.status;
+    out->unlocked = is_runnable(v.status) ? 1 : 0;
+    out->grace_days_left = v.grace_days_left;
+    out->generation = rt->sh->generation.load();
+    copy_text(out->message, sizeof out->message, v.message);
+    copy_text(out->sign_in_url, sizeof out->sign_in_url, v.sign_in_url);
+    copy_text(out->username, sizeof out->username, v.username);
+}
+
+void ap_get_update_state(ap_runtime *rt, ap_update_state *out) {
+    if (!out) return;
+    std::memset(out, 0, sizeof *out);
+    if (!rt) return;
+    std::lock_guard<std::mutex> l(rt->sh->view_mu);
+    const UpdateView &v = rt->sh->update;
+    out->status = (ap_update_status)v.status;
+    out->restart_required = v.restart_required;
+    out->needs_manual_install = v.needs_manual_install;
+    copy_text(out->version, sizeof out->version, v.version);
+    copy_text(out->direction, sizeof out->direction, v.direction);
+    copy_text(out->change_log, sizeof out->change_log, v.change_log);
+    copy_text(out->error_code, sizeof out->error_code, v.error_code);
+    copy_text(out->error_message, sizeof out->error_message, v.error_message);
+}
+
+int ap_begin_sign_in(ap_runtime *rt) {
+    if (!rt || !rt->sh->settings.license_enabled) return -1;
+    rt->sh->post({Cmd::SignIn, ""});
+    return 0;
+}
+
+void ap_cancel_sign_in(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::CancelSignIn, ""}); }
+void ap_open_sign_in_page(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::OpenPage, ""}); }
+void ap_retry(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::Retry, ""}); }
+void ap_sign_out(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::SignOut, ""}); }
+void ap_check_for_update(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::CheckUpdate, ""}); }
+void ap_download_update(ap_runtime *rt) { if (rt) rt->sh->post({Cmd::Download, ""}); }
+
+ap_apply_result ap_apply_staged_update(ap_runtime *rt) {
+    if (!rt) return AP_APPLY_NOTHING;
+    auto &sh = *rt->sh;
+    std::string version, error;
+    ApplyResult r = apply_staged_update(sh.settings, sh.env, &version, &error);
+    if (r == ApplyResult::Ok) {
+        sh.post({Cmd::MarkApplied, version});
+        std::lock_guard<std::mutex> l(sh.view_mu);
+        sh.update.status = UpdStatus::Applied;
+        sh.update.restart_required = true;
+        sh.update.version = version;
+        sh.notice = "Update installed: restart After Effects to use v" + version;
+    } else if (r == ApplyResult::NotWritable || r == ApplyResult::NotInstalled) {
+        std::lock_guard<std::mutex> l(sh.view_mu);
+        sh.update.needs_manual_install = true;
+        sh.update.error_code = r == ApplyResult::NotWritable ? "not_writable" : "not_installed";
+        sh.update.error_message = error;
+    }
+    if (r != ApplyResult::Nothing) sh.generation.fetch_add(1);
+    sh.logger.flush();
+    return (ap_apply_result)r;
+}
+
+size_t ap_update_notice(ap_runtime *rt, char *buf, size_t size) {
+    if (!rt) { if (buf && size) buf[0] = '\0'; return 0; }
+    std::lock_guard<std::mutex> l(rt->sh->view_mu);
+    if (buf && size) copy_text(buf, size, rt->sh->notice);
+    return rt->sh->notice.size();
+}
+
+size_t ap_update_changelog(ap_runtime *rt, char *buf, size_t size) {
+    if (!rt) { if (buf && size) buf[0] = '\0'; return 0; }
+    std::lock_guard<std::mutex> l(rt->sh->view_mu);
+    if (buf && size) copy_text(buf, size, rt->sh->update.change_log);
+    return rt->sh->update.change_log.size();
+}
+
+ap_dialog_action ap_options_dialog(ap_runtime *rt, const char *title) {
+    if (!rt) return AP_DIALOG_NONE;
+    auto &sh = *rt->sh;
+    DialogModel model;
+    {
+        std::lock_guard<std::mutex> l(sh.view_mu);
+        model = options_dialog_model(title ? title : "", sh.license, sh.update, sh.notice, sh.settings.product_url,
+                                     sh.settings.manage_devices_url);
+    }
+    int index = platform_show_dialog(model);
+    if (index < 0 || index >= (int)model.buttons.size()) return index < 0 ? AP_DIALOG_NONE : AP_DIALOG_CLOSE;
+    switch (model.buttons[(size_t)index].action) {
+        case DialogAction::Close: return AP_DIALOG_CLOSE;
+        case DialogAction::SignIn: sh.post({Cmd::SignIn, ""}); return AP_DIALOG_SIGN_IN;
+        case DialogAction::OpenSignInPage: sh.post({Cmd::OpenPage, ""}); return AP_DIALOG_OPEN_SIGN_IN_PAGE;
+        case DialogAction::CancelSignIn: sh.post({Cmd::CancelSignIn, ""}); return AP_DIALOG_CANCEL_SIGN_IN;
+        case DialogAction::SignOut: sh.post({Cmd::SignOut, ""}); return AP_DIALOG_SIGN_OUT;
+        case DialogAction::Retry: sh.post({Cmd::Retry, ""}); return AP_DIALOG_RETRY;
+        case DialogAction::OpenProduct: sh.env.open_url(sh.settings.product_url); return AP_DIALOG_OPEN_PRODUCT;
+        case DialogAction::ManageDevices: sh.env.open_url(sh.settings.manage_devices_url); return AP_DIALOG_MANAGE_DEVICES;
+    }
+    return AP_DIALOG_CLOSE;
+}
+
+int ap_wait_idle(ap_runtime *rt, int timeout_ms) {
+    if (!rt) return -1;
+    auto &sh = *rt->sh;
+    std::unique_lock<std::mutex> l(sh.q_mu);
+    bool ok = sh.idle_cv.wait_for(l, std::chrono::milliseconds(timeout_ms),
+                                  [&] { return sh.finished || (sh.queue.empty() && !sh.busy); });
+    return ok ? 0 : -1;
+}
+
+void ap_log(ap_runtime *rt, int level, const char *message) {
+    if (!rt || !message) return;
+    auto &sh = *rt->sh;
+    sh.logger.push(level, message, sh.env.now_ms(), false);  // never blocks
+}
+
+size_t ap_log_path(ap_runtime *rt, char *buf, size_t size) {
+    if (!rt) return 0;
+    const std::string &p = rt->sh->logger.path();
+    if (buf && size) copy_text(buf, size, p);
+    return p.size();
+}
+
+const char *ap_status_name(ap_status s) { return status_name((Status)s); }
+const char *ap_update_status_name(ap_update_status s) { return upd_status_name((UpdStatus)s); }
+
+}  // extern "C"

package/native-runtime/src/util.cpp

@@ -0,0 +1,169 @@
+#include "util.hpp"
+
+#include <cctype>
+#include <cstdio>
+#include <regex>
+
+#include "crypto.hpp"
+#include "fsutil.hpp"
+
+namespace apn {
+
+namespace {
+
+// Days since 1970-01-01 for a proleptic Gregorian date (Howard Hinnant's algorithm).
+int64_t days_from_civil(int64_t y, unsigned m, unsigned d) {
+    y -= m <= 2;
+    const int64_t era = (y >= 0 ? y : y - 399) / 400;
+    const unsigned yoe = (unsigned)(y - era * 400);
+    const unsigned doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+    const unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    return era * 146097 + (int64_t)doe - 719468;
+}
+
+void civil_from_days(int64_t z, int64_t &y, unsigned &m, unsigned &d) {
+    z += 719468;
+    const int64_t era = (z >= 0 ? z : z - 146096) / 146097;
+    const unsigned doe = (unsigned)(z - era * 146097);
+    const unsigned yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    y = (int64_t)yoe + era * 400;
+    const unsigned doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    const unsigned mp = (5 * doy + 2) / 153;
+    d = doy - (153 * mp + 2) / 5 + 1;
+    m = mp < 10 ? mp + 3 : mp - 9;
+    y += m <= 2;
+}
+
+bool digits(const std::string &s, size_t pos, size_t n, int &out) {
+    if (pos + n > s.size()) return false;
+    out = 0;
+    for (size_t i = 0; i < n; i++) {
+        char c = s[pos + i];
+        if (c < '0' || c > '9') return false;
+        out = out * 10 + (c - '0');
+    }
+    return true;
+}
+
+}  // namespace
+
+std::optional<int64_t> parse_iso8601(const std::string &s) {
+    int Y, M, D, h, m, sec;
+    if (!digits(s, 0, 4, Y) || s.size() < 19 || s[4] != '-' || !digits(s, 5, 2, M) || s[7] != '-' ||
+        !digits(s, 8, 2, D) || (s[10] != 'T' && s[10] != 't' && s[10] != ' ') || !digits(s, 11, 2, h) ||
+        s[13] != ':' || !digits(s, 14, 2, m) || s[16] != ':' || !digits(s, 17, 2, sec)) {
+        return std::nullopt;
+    }
+    if (M < 1 || M > 12 || D < 1 || D > 31 || h > 24 || m > 59 || sec > 59) return std::nullopt;
+    size_t p = 19;
+    int64_t ms = 0;
+    if (p < s.size() && s[p] == '.') {
+        p++;
+        size_t start = p;
+        int scale = 100;
+        while (p < s.size() && std::isdigit((unsigned char)s[p])) {
+            if (scale > 0) { ms += (s[p] - '0') * scale; scale /= 10; }
+            p++;
+        }
+        if (p == start) return std::nullopt;
+    }
+    int64_t offset_min = 0;
+    if (p < s.size() && (s[p] == 'Z' || s[p] == 'z')) {
+        p++;
+    } else if (p < s.size() && (s[p] == '+' || s[p] == '-')) {
+        int oh, om;
+        int sign = s[p] == '-' ? -1 : 1;
+        if (!digits(s, p + 1, 2, oh) || p + 3 >= s.size() || s[p + 3] != ':' || !digits(s, p + 4, 2, om)) return std::nullopt;
+        offset_min = sign * (oh * 60 + om);
+        p += 6;
+    } else {
+        return std::nullopt;  // no zone: refuse rather than guess local time
+    }
+    if (p != s.size()) return std::nullopt;
+    int64_t days = days_from_civil(Y, (unsigned)M, (unsigned)D);
+    int64_t total = ((days * 24 + h) * 60 + m) * 60 + sec;
+    return total * 1000 + ms - offset_min * 60 * 1000;
+}
+
+std::string format_iso8601(int64_t ms) {
+    int64_t secs = ms >= 0 ? ms / 1000 : -((-ms + 999) / 1000);
+    int64_t rem_ms = ms - secs * 1000;
+    int64_t days = secs >= 0 ? secs / 86400 : -((-secs + 86399) / 86400);
+    int64_t sod = secs - days * 86400;
+    int64_t y;
+    unsigned mo, d;
+    civil_from_days(days, y, mo, d);
+    char buf[40];
+    std::snprintf(buf, sizeof buf, "%04lld-%02u-%02uT%02d:%02d:%02d.%03dZ", (long long)y, mo, d, (int)(sod / 3600),
+                  (int)(sod / 60 % 60), (int)(sod % 60), (int)rem_ms);
+    return buf;
+}
+
+bool is_semver(const std::string &v) {
+    static const std::regex re(
+        R"(^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$)");
+    return v.size() <= 64 && std::regex_match(v, re);
+}
+
+bool is_bundle_id(const std::string &id) {
+    static const std::regex re(R"(^com\.afterpresets\.[a-z0-9]{1,64}\.[a-z0-9-]{2,40}$)");
+    return id.size() <= 255 && std::regex_match(id, re);
+}
+
+bool is_http_url(const std::string &url) {
+    auto lower = url.substr(0, 8);
+    for (auto &c : lower) c = (char)std::tolower((unsigned char)c);
+    return lower.rfind("https://", 0) == 0 || lower.rfind("http://", 0) == 0;
+}
+
+bool is_allowed_api_base(const std::string &url) {
+    static const std::regex https(R"(^https://[A-Za-z0-9.-]+(:\d{1,5})?(/[^\s?#]*)?$)");
+    static const std::regex local(R"(^http://(127\.0\.0\.1|localhost|\[::1\])(:\d{1,5})?(/[^\s?#]*)?$)");
+    return std::regex_match(url, https) || std::regex_match(url, local);
+}
+
+std::string computer_id_path(const std::string &data_root) {
+    return fsu::join(fsu::join(data_root, "AfterPresets"), "computer-id");
+}
+
+namespace {
+
+std::optional<std::string> read_saved_id(const std::string &file, const Env &env) {
+    auto text = fsu::read(file, 4096);
+    if (!text) return std::nullopt;
+    std::string id;
+    for (char c : *text) {
+        if (c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v') continue;
+        id += (char)std::tolower((unsigned char)c);
+    }
+    static const std::regex re("^[a-f0-9]{64}$");
+    if (std::regex_match(id, re)) return id;
+    if (env.log) env.log(2, "Saved computer ID is malformed; creating a new one.");
+    return std::nullopt;
+}
+
+}  // namespace
+
+std::string computer_id(const Env &env) {
+    std::string file = computer_id_path(env.data_root);
+    if (auto saved = read_saved_id(file, env)) return *saved;
+    std::optional<std::string> fingerprint;
+    if (env.hardware_fingerprint) fingerprint = env.hardware_fingerprint();
+    if (!fingerprint && env.mac_fingerprint) fingerprint = env.mac_fingerprint();
+    if (!fingerprint) fingerprint = "random:" + env.random_hex(32);
+    std::string id = sha256_hex(*fingerprint);
+    // Save unless another process saved one first (then use theirs), like the JS runtime.
+    if (fsu::exists(file)) fsu::remove_file(file);  // only reached when the saved file is malformed
+    switch (fsu::write_exclusive(file, id)) {
+        case fsu::Excl::Ok: return id;
+        case fsu::Excl::Exists: {
+            auto other = read_saved_id(file, env);
+            return other ? *other : id;
+        }
+        default:
+            if (env.log) env.log(2, "Could not save the computer ID");
+            return id;
+    }
+}
+
+}  // namespace apn

package/native-runtime/src/util.hpp

@@ -0,0 +1,32 @@
+// Small shared helpers: ISO-8601 time, semver, bundle id and URL checks, computer id.
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+#include "platform.hpp"
+
+namespace apn {
+
+constexpr int64_t DAY_MS = 24LL * 60 * 60 * 1000;
+
+// Date.parse for the forms the API writes: YYYY-MM-DDTHH:MM:SS[.fff]Z or ±HH:MM offset.
+std::optional<int64_t> parse_iso8601(const std::string &text);
+// new Date(ms).toISOString(): 2026-11-06T11:10:38.969Z
+std::string format_iso8601(int64_t ms);
+
+bool is_semver(const std::string &v);
+// The API's BUNDLE_ID_PATTERN: com.afterpresets.<seller>.<slug>.
+bool is_bundle_id(const std::string &id);
+// https://..., or http:// only for 127.0.0.1 / localhost / [::1] (local development).
+bool is_allowed_api_base(const std::string &url);
+bool is_http_url(const std::string &url);
+
+// <data_root>/AfterPresets/computer-id, shared with every AfterPresets runtime on the machine.
+std::string computer_id_path(const std::string &data_root);
+// Same precedence and value as packages/runtime/src/computer-id.js: the saved
+// file, else sha256(hardware fingerprint | MAC list | random), saved once with "wx".
+std::string computer_id(const Env &env);
+
+}  // namespace apn