afterpresets 0.2.0 → 0.3.0

package/native-runtime/src/json.cpp

@@ -0,0 +1,326 @@
+#include "json.hpp"
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+#include <cstring>
+
+namespace apn {
+
+namespace {
+constexpr int kMaxDepth = 64;
+constexpr size_t kMaxInput = 8 * 1024 * 1024;
+
+void append_utf8(std::string &out, uint32_t cp) {
+    if (cp < 0x80) {
+        out += (char)cp;
+    } else if (cp < 0x800) {
+        out += (char)(0xC0 | (cp >> 6));
+        out += (char)(0x80 | (cp & 0x3F));
+    } else if (cp < 0x10000) {
+        out += (char)(0xE0 | (cp >> 12));
+        out += (char)(0x80 | ((cp >> 6) & 0x3F));
+        out += (char)(0x80 | (cp & 0x3F));
+    } else {
+        out += (char)(0xF0 | (cp >> 18));
+        out += (char)(0x80 | ((cp >> 12) & 0x3F));
+        out += (char)(0x80 | ((cp >> 6) & 0x3F));
+        out += (char)(0x80 | (cp & 0x3F));
+    }
+}
+}  // namespace
+
+class JsonParser {
+public:
+    explicit JsonParser(const std::string &s) : s_(s) {}
+
+    bool parse(Json &out) {
+        ws();
+        if (!value(out, 0)) return false;
+        ws();
+        return p_ == s_.size();
+    }
+
+private:
+    void ws() {
+        while (p_ < s_.size() && (s_[p_] == ' ' || s_[p_] == '\t' || s_[p_] == '\n' || s_[p_] == '\r')) p_++;
+    }
+    bool lit(const char *word) {
+        size_t n = std::strlen(word);
+        if (s_.compare(p_, n, word) != 0) return false;
+        p_ += n;
+        return true;
+    }
+    bool hex4(uint32_t &v) {
+        if (p_ + 4 > s_.size()) return false;
+        v = 0;
+        for (int i = 0; i < 4; i++) {
+            char c = s_[p_++];
+            v <<= 4;
+            if (c >= '0' && c <= '9') v |= (uint32_t)(c - '0');
+            else if (c >= 'a' && c <= 'f') v |= (uint32_t)(c - 'a' + 10);
+            else if (c >= 'A' && c <= 'F') v |= (uint32_t)(c - 'A' + 10);
+            else return false;
+        }
+        return true;
+    }
+    bool string(std::string &out) {
+        if (p_ >= s_.size() || s_[p_] != '"') return false;
+        p_++;
+        while (p_ < s_.size()) {
+            unsigned char c = (unsigned char)s_[p_++];
+            if (c == '"') return true;
+            if (c < 0x20) return false;
+            if (c != '\\') { out += (char)c; continue; }
+            if (p_ >= s_.size()) return false;
+            char e = s_[p_++];
+            switch (e) {
+                case '"': out += '"'; break;
+                case '\\': out += '\\'; break;
+                case '/': out += '/'; break;
+                case 'b': out += '\b'; break;
+                case 'f': out += '\f'; break;
+                case 'n': out += '\n'; break;
+                case 'r': out += '\r'; break;
+                case 't': out += '\t'; break;
+                case 'u': {
+                    uint32_t cp;
+                    if (!hex4(cp)) return false;
+                    if (cp >= 0xD800 && cp <= 0xDBFF) {
+                        uint32_t lo;
+                        if (p_ + 2 <= s_.size() && s_[p_] == '\\' && s_[p_ + 1] == 'u') {
+                            p_ += 2;
+                            if (!hex4(lo)) return false;
+                            if (lo >= 0xDC00 && lo <= 0xDFFF) cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
+                            else { append_utf8(out, 0xFFFD); cp = lo; }
+                        } else {
+                            cp = 0xFFFD;
+                        }
+                    } else if (cp >= 0xDC00 && cp <= 0xDFFF) {
+                        cp = 0xFFFD;
+                    }
+                    append_utf8(out, cp);
+                    break;
+                }
+                default: return false;
+            }
+        }
+        return false;
+    }
+    bool number(Json &out) {
+        size_t start = p_;
+        if (s_[p_] == '-') p_++;
+        if (p_ >= s_.size()) return false;
+        if (s_[p_] == '0') p_++;
+        else if (s_[p_] >= '1' && s_[p_] <= '9') { while (p_ < s_.size() && isdigit((unsigned char)s_[p_])) p_++; }
+        else return false;
+        if (p_ < s_.size() && s_[p_] == '.') {
+            p_++;
+            if (p_ >= s_.size() || !isdigit((unsigned char)s_[p_])) return false;
+            while (p_ < s_.size() && isdigit((unsigned char)s_[p_])) p_++;
+        }
+        if (p_ < s_.size() && (s_[p_] == 'e' || s_[p_] == 'E')) {
+            p_++;
+            if (p_ < s_.size() && (s_[p_] == '+' || s_[p_] == '-')) p_++;
+            if (p_ >= s_.size() || !isdigit((unsigned char)s_[p_])) return false;
+            while (p_ < s_.size() && isdigit((unsigned char)s_[p_])) p_++;
+        }
+        std::string text = s_.substr(start, p_ - start);
+        out = Json::number(std::strtod(text.c_str(), nullptr));
+        return true;
+    }
+    bool value(Json &out, int depth) {
+        if (depth > kMaxDepth || p_ >= s_.size()) return false;
+        char c = s_[p_];
+        if (c == '{') {
+            p_++;
+            out = Json::object();
+            ws();
+            if (p_ < s_.size() && s_[p_] == '}') { p_++; return true; }
+            for (;;) {
+                ws();
+                std::string key;
+                if (!string(key)) return false;
+                ws();
+                if (p_ >= s_.size() || s_[p_] != ':') return false;
+                p_++;
+                ws();
+                Json v;
+                if (!value(v, depth + 1)) return false;
+                out.set(key, std::move(v));
+                ws();
+                if (p_ >= s_.size()) return false;
+                if (s_[p_] == ',') { p_++; continue; }
+                if (s_[p_] == '}') { p_++; return true; }
+                return false;
+            }
+        }
+        if (c == '[') {
+            p_++;
+            out = Json::array();
+            ws();
+            if (p_ < s_.size() && s_[p_] == ']') { p_++; return true; }
+            for (;;) {
+                ws();
+                Json v;
+                if (!value(v, depth + 1)) return false;
+                out.push(std::move(v));
+                ws();
+                if (p_ >= s_.size()) return false;
+                if (s_[p_] == ',') { p_++; continue; }
+                if (s_[p_] == ']') { p_++; return true; }
+                return false;
+            }
+        }
+        if (c == '"') {
+            std::string str;
+            if (!string(str)) return false;
+            out = Json::string(std::move(str));
+            return true;
+        }
+        if (c == 't') { if (!lit("true")) return false; out = Json::boolean(true); return true; }
+        if (c == 'f') { if (!lit("false")) return false; out = Json::boolean(false); return true; }
+        if (c == 'n') { if (!lit("null")) return false; out = Json(); return true; }
+        if (c == '-' || (c >= '0' && c <= '9')) return number(out);
+        return false;
+    }
+
+    const std::string &s_;
+    size_t p_ = 0;
+};
+
+const Json &Json::operator[](const std::string &key) const {
+    static const Json null_value;
+    if (type_ != Type::Object) return null_value;
+    // Last duplicate wins, like JSON.parse.
+    for (auto it = object_.rbegin(); it != object_.rend(); ++it) {
+        if (it->first == key) return it->second;
+    }
+    return null_value;
+}
+
+bool Json::has(const std::string &key) const {
+    if (type_ != Type::Object) return false;
+    for (const auto &kv : object_) {
+        if (kv.first == key) return true;
+    }
+    return false;
+}
+
+Json &Json::set(const std::string &key, Json value) {
+    if (type_ != Type::Object) { *this = object(); }
+    for (auto &kv : object_) {
+        if (kv.first == key) { kv.second = std::move(value); return kv.second; }
+    }
+    object_.emplace_back(key, std::move(value));
+    return object_.back().second;
+}
+
+const Json &Json::at(size_t i) const {
+    static const Json null_value;
+    if (type_ != Type::Array || i >= array_.size()) return null_value;
+    return array_[i];
+}
+
+Json &Json::push(Json value) {
+    if (type_ != Type::Array) { *this = array(); }
+    array_.push_back(std::move(value));
+    return array_.back();
+}
+
+std::string Json::str(const std::string &fallback) const {
+    switch (type_) {
+        case Type::String: return string_;
+        case Type::Bool: return bool_ ? "true" : "false";
+        case Type::Number: {
+            if (std::isfinite(number_) && std::floor(number_) == number_ && std::fabs(number_) < 9007199254740992.0) {
+                char buf[32];
+                std::snprintf(buf, sizeof buf, "%.0f", number_);
+                return buf;
+            }
+            char buf[40];
+            std::snprintf(buf, sizeof buf, "%.17g", number_);
+            return buf;
+        }
+        default: return fallback;
+    }
+}
+
+static void dump_string(std::string &out, const std::string &s) {
+    out += '"';
+    for (unsigned char c : s) {
+        switch (c) {
+            case '"': out += "\\\""; break;
+            case '\\': out += "\\\\"; break;
+            case '\b': out += "\\b"; break;
+            case '\f': out += "\\f"; break;
+            case '\n': out += "\\n"; break;
+            case '\r': out += "\\r"; break;
+            case '\t': out += "\\t"; break;
+            default:
+                if (c < 0x20) {
+                    char buf[8];
+                    std::snprintf(buf, sizeof buf, "\\u%04x", c);
+                    out += buf;
+                } else {
+                    out += (char)c;
+                }
+        }
+    }
+    out += '"';
+}
+
+void Json::dump_to(std::string &out, bool pretty, int indent) const {
+    auto newline = [&](int level) {
+        if (!pretty) return;
+        out += '\n';
+        out.append((size_t)level * 2, ' ');
+    };
+    switch (type_) {
+        case Type::Null: out += "null"; break;
+        case Type::Bool: out += bool_ ? "true" : "false"; break;
+        case Type::Number: out += std::isfinite(number_) ? str() : "null"; break;
+        case Type::String: dump_string(out, string_); break;
+        case Type::Array:
+            if (array_.empty()) { out += "[]"; break; }
+            out += '[';
+            for (size_t i = 0; i < array_.size(); i++) {
+                if (i) out += ',';
+                newline(indent + 1);
+                array_[i].dump_to(out, pretty, indent + 1);
+            }
+            newline(indent);
+            out += ']';
+            break;
+        case Type::Object:
+            if (object_.empty()) { out += "{}"; break; }
+            out += '{';
+            for (size_t i = 0; i < object_.size(); i++) {
+                if (i) out += ',';
+                newline(indent + 1);
+                dump_string(out, object_[i].first);
+                out += pretty ? ": " : ":";
+                object_[i].second.dump_to(out, pretty, indent + 1);
+            }
+            newline(indent);
+            out += '}';
+            break;
+    }
+}
+
+std::string Json::dump(bool pretty) const {
+    std::string out;
+    dump_to(out, pretty, 0);
+    return out;
+}
+
+std::optional<Json> Json::parse(const std::string &text) {
+    if (text.size() > kMaxInput) return std::nullopt;
+    Json out;
+    JsonParser parser(text);
+    if (!parser.parse(out)) return std::nullopt;
+    return out;
+}
+
+}  // namespace apn

package/native-runtime/src/json.hpp

@@ -0,0 +1,70 @@
+// Minimal JSON (RFC 8259) value, parser and serializer for ap_native.
+// Inputs are small API responses and cache files; limits: depth 64, 8 MB.
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace apn {
+
+class Json {
+public:
+    enum class Type { Null, Bool, Number, String, Array, Object };
+
+    Json() = default;
+    static Json null() { return Json(); }
+    static Json boolean(bool b) { Json j; j.type_ = Type::Bool; j.bool_ = b; return j; }
+    static Json number(double n) { Json j; j.type_ = Type::Number; j.number_ = n; return j; }
+    static Json string(std::string s) { Json j; j.type_ = Type::String; j.string_ = std::move(s); return j; }
+    static Json array() { Json j; j.type_ = Type::Array; return j; }
+    static Json object() { Json j; j.type_ = Type::Object; return j; }
+
+    Type type() const { return type_; }
+    bool is_null() const { return type_ == Type::Null; }
+    bool is_string() const { return type_ == Type::String; }
+    bool is_number() const { return type_ == Type::Number; }
+    bool is_bool() const { return type_ == Type::Bool; }
+    bool is_object() const { return type_ == Type::Object; }
+    bool is_array() const { return type_ == Type::Array; }
+
+    bool as_bool() const { return type_ == Type::Bool && bool_; }
+    double as_number(double fallback = 0) const { return type_ == Type::Number ? number_ : fallback; }
+    const std::string &as_string() const { static const std::string empty; return type_ == Type::String ? string_ : empty; }
+
+    // Object access: missing keys (or a non-object) give a shared null.
+    const Json &operator[](const std::string &key) const;
+    bool has(const std::string &key) const;
+    // Inserts or replaces (keeps insertion order for serialization).
+    Json &set(const std::string &key, Json value);
+    const std::vector<std::pair<std::string, Json>> &items() const { return object_; }
+
+    // Array access.
+    size_t size() const { return type_ == Type::Array ? array_.size() : 0; }
+    const Json &at(size_t i) const;
+    Json &push(Json value);
+
+    // String value of a string, number (integral) or bool; fallback otherwise.
+    std::string str(const std::string &fallback = "") const;
+
+    std::string dump(bool pretty = false) const;
+    static std::optional<Json> parse(const std::string &text);
+
+private:
+    void dump_to(std::string &out, bool pretty, int indent) const;
+
+    Type type_ = Type::Null;
+    bool bool_ = false;
+    double number_ = 0;
+    std::string string_;
+    std::vector<Json> array_;
+    std::vector<std::pair<std::string, Json>> object_;
+
+    friend class JsonParser;
+};
+
+}  // namespace apn

package/native-runtime/src/platform.hpp

@@ -0,0 +1,83 @@
+// Platform seams for ap_native. Everything the engine needs from the OS goes
+// through Env, so tests replace the network, clock, browser and fingerprint.
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace apn {
+
+struct HttpRequest {
+    std::string method = "POST";
+    std::string url;
+    std::string body;                                          // sent when non-empty (JSON)
+    std::vector<std::pair<std::string, std::string>> headers;  // in addition to Accept/User-Agent
+    int timeout_ms = 20000;                                    // whole request (JS runtime: 20 s)
+    std::string download_path;                                 // non-empty: stream the body to this file
+    uint64_t max_bytes = 4 * 1024 * 1024;                      // larger bodies fail as network errors
+    bool follow_redirects = false;                             // GET downloads only
+};
+
+struct HttpResponse {
+    bool network_error = false;  // connection failure, timeout, cancel, TLS, too large
+    std::string error;           // short reason; never contains the URL
+    int status = 0;
+    std::string body;            // empty when download_path was used
+    std::string content_type;
+};
+
+class HttpClient {
+public:
+    virtual ~HttpClient() = default;
+    // Blocking; called only on the worker thread. Must return promptly once
+    // `cancel` becomes true.
+    virtual HttpResponse send(const HttpRequest &request, const std::atomic<bool> &cancel) = 0;
+};
+
+// NSURLSession (macOS) / WinHTTP (Windows). Ephemeral: no cookies, no cache,
+// no stored credentials.
+std::shared_ptr<HttpClient> make_platform_http(const std::string &user_agent);
+
+struct Env {
+    std::shared_ptr<HttpClient> http;
+    std::function<int64_t()> now_ms;                              // Unix epoch milliseconds
+    std::function<bool(const std::string &)> open_url;            // default browser
+    std::string data_root;                                        // machine data root, see platform_data_root()
+    std::function<std::optional<std::string>()> hardware_fingerprint;
+    std::function<std::optional<std::string>()> mac_fingerprint;
+    std::function<std::string(size_t)> random_hex;                // cryptographically random, 2*n hex chars
+    std::function<bool(const std::string &)> strip_quarantine;    // macOS: remove com.apple.quarantine recursively
+    std::function<void(int, const std::string &)> log;
+};
+
+// Real implementations.
+Env platform_env(const std::string &user_agent);
+// ~/Library/Application Support (macOS, = CEP USER_DATA) or the non-roaming
+// %LOCALAPPDATA% (Windows). Empty if it cannot be determined.
+std::string platform_data_root();
+// "mac:<IOPlatformUUID upper>" / "win:<MachineGuid upper>"; same strings as the JS runtime.
+std::optional<std::string> platform_hardware_fingerprint();
+// "mac-list:<sorted physical MACs>"; same filter as the JS runtime.
+std::optional<std::string> platform_mac_fingerprint();
+bool platform_open_url(const std::string &url);
+std::string platform_random_hex(size_t bytes);
+// Absolute path of the binary (plugin) that contains this library.
+std::string platform_self_binary_path();
+bool platform_strip_quarantine(const std::string &path);
+// "macos" / "windows"; "arm64" / "x64".
+const char *platform_os();
+const char *platform_arch();
+
+// Pure helper shared with tests: the JS runtime's MAC filter.
+// interfaces: (name, mac "aa:bb:..", is_loopback).
+std::optional<std::string> mac_fingerprint_from(
+    const std::vector<std::tuple<std::string, std::string, bool>> &interfaces);
+
+}  // namespace apn

package/native-runtime/src/platform_common.cpp

@@ -0,0 +1,60 @@
+#include <algorithm>
+#include <chrono>
+#include <cstdlib>
+#include <regex>
+#include <set>
+
+#include "platform.hpp"
+
+namespace apn {
+
+std::optional<std::string> mac_fingerprint_from(
+    const std::vector<std::tuple<std::string, std::string, bool>> &interfaces) {
+    // Same filter as packages/runtime/src/computer-id.js (VIRTUAL_IFACE, internal,
+    // all-zero and locally administered MACs).
+    static const std::regex virtual_iface(
+        "^(awdl|llw|utun|bridge|vmnet|vnic|gif|stf|anpi|ap\\d|tun|tap|lo|docker|veth|zt|wg|vboxnet|vEthernet)",
+        std::regex::icase);
+    std::set<std::string> seen;
+    for (const auto &iface : interfaces) {
+        const std::string &name = std::get<0>(iface);
+        std::string mac = std::get<1>(iface);
+        if (std::regex_search(name, virtual_iface)) continue;
+        if (std::get<2>(iface) || mac.empty()) continue;
+        std::transform(mac.begin(), mac.end(), mac.begin(), [](unsigned char c) { return (char)std::tolower(c); });
+        if (mac == "00:00:00:00:00:00") continue;
+        const std::string octet = mac.substr(0, mac.find(':'));  // must outlive `end`
+        char *end = nullptr;
+        long first = std::strtol(octet.c_str(), &end, 16);
+        if (!end || *end != '\0' || (first & 2)) continue;
+        seen.insert(mac);
+    }
+    if (seen.empty()) return std::nullopt;
+    std::string out = "mac-list:";
+    bool firstItem = true;
+    for (const auto &m : seen) {  // std::set iterates sorted, like Object.keys(...).sort()
+        if (!firstItem) out += ',';
+        out += m;
+        firstItem = false;
+    }
+    return out;
+}
+
+Env platform_env(const std::string &user_agent) {
+    Env env;
+    env.http = make_platform_http(user_agent);
+    env.now_ms = [] {
+        return (int64_t)std::chrono::duration_cast<std::chrono::milliseconds>(
+                   std::chrono::system_clock::now().time_since_epoch())
+            .count();
+    };
+    env.open_url = platform_open_url;
+    env.data_root = platform_data_root();
+    env.hardware_fingerprint = platform_hardware_fingerprint;
+    env.mac_fingerprint = platform_mac_fingerprint;
+    env.random_hex = platform_random_hex;
+    env.strip_quarantine = platform_strip_quarantine;
+    return env;
+}
+
+}  // namespace apn