afterpresets 0.2.0 → 0.4.0

package/native-runtime/src/engine.hpp

@@ -0,0 +1,232 @@
+// License state machine and updater for ap_native. A port of
+// packages/runtime/src/license.js and updates.js with the same API calls,
+// statuses, cache file and proof rules. Single-threaded: only the worker
+// thread (or a test) calls into an Engine.
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <string>
+
+#include "crypto.hpp"
+#include "fsutil.hpp"
+#include "json.hpp"
+#include "platform.hpp"
+
+namespace apn {
+
+enum class Status { Disabled, SignedOut, SigningIn, Checking, Active, NotOwned, Refunded, OfflineGrace, OfflineExpired, Error };
+enum class UpdateMode { Off, Manual, Notify, Background };
+enum class UpdStatus { Idle, Checking, UpToDate, Available, Downloading, Staged, Applied, Error };
+enum class ApplyResult { Nothing = 0, Ok = 1, NotInstalled = -1, NotWritable = -2, Failed = -3, Dev = -4 };
+
+const char *status_name(Status s);
+const char *upd_status_name(UpdStatus s);
+bool is_runnable(Status s);
+
+struct Settings {
+    std::string bundle_id;
+    std::string version;
+    std::string api_base;
+    std::string product_url;
+    std::string manage_devices_url;
+    std::string channel = "production";
+    std::optional<PublicKey> public_key;  // nullopt: proofs cannot be verified (always check online)
+    bool license_enabled = true;
+    int grace_days = 0;
+    bool background = true;
+    UpdateMode update_mode = UpdateMode::Background;
+    bool dev = false;
+    bool apply_when_staged = true;  // replace the installed plugin right after staging (in-session notice)
+    std::string install_dir;  // installed <bundleId> folder, "" when not installed
+    std::string os = "macos";
+    std::string arch = "arm64";
+    std::string runtime_version = "0.1.0";
+    int64_t first_update_check_delay_ms = 15 * 1000;
+};
+
+struct LicenseView {
+    Status status = Status::Checking;
+    std::string message;
+    int grace_days_left = 0;
+    std::string sign_in_url;
+    std::string username;
+    bool operator==(const LicenseView &o) const {
+        return status == o.status && message == o.message && grace_days_left == o.grace_days_left &&
+               sign_in_url == o.sign_in_url && username == o.username;
+    }
+};
+
+struct UpdateView {
+    UpdStatus status = UpdStatus::Idle;
+    bool restart_required = false;
+    bool needs_manual_install = false;
+    std::string version;
+    std::string direction;
+    std::string change_log;
+    std::string error_code;
+    std::string error_message;
+    bool operator==(const UpdateView &o) const {
+        return status == o.status && restart_required == o.restart_required &&
+               needs_manual_install == o.needs_manual_install && version == o.version && direction == o.direction &&
+               change_log == o.change_log && error_code == o.error_code && error_message == o.error_message;
+    }
+};
+
+// Outcome of one API call, classified like the JS runtime's _.api().
+struct ApiResult {
+    enum Kind { Ok, Network, Rejected } kind = Network;
+    Json json;
+    std::string code;
+    std::string message;
+    int status = 0;
+};
+
+// Paths under <data_root>/AfterPresets/extensions/<bundleId>/ (the JS runtime's layout).
+struct Paths {
+    std::string data_dir;
+    std::string license;     // license.json
+    std::string updates;     // updates.json
+    std::string lock;        // update.lock
+    std::string updates_dir; // updates/
+    std::string staged;      // updates/staged/   (holds <Name>.plugin or <Name>.aex)
+    std::string staged_meta; // updates/staged.json
+    static Paths make(const std::string &data_root, const std::string &bundle_id);
+};
+
+class Engine {
+public:
+    static constexpr int64_t CLOCK_SKEW_MS = 24LL * 60 * 60 * 1000;
+    static constexpr int64_t MIN_POLL_MS = 250;
+    static constexpr int64_t QUIET_RETRY_MS = 30LL * 60 * 1000;
+    static constexpr int64_t CACHE_WATCH_MS = 30LL * 1000;
+    static constexpr int64_t UPDATE_INTERVAL_MS = 6LL * 60 * 60 * 1000;
+    static constexpr int64_t LOCK_STALE_MS = 10LL * 60 * 1000;
+
+    Engine(Settings settings, Env env, std::function<void()> on_change);
+
+    // ---- license ----
+    enum class Launch { None, Validate, ValidateBehind };
+    // Launch decision from disk only (no network). Validate: status CHECKING,
+    // call validate_stored(); ValidateBehind: unlocked from a signed stale
+    // check, call validate_behind().
+    Launch launch_local();
+    void validate_stored();   // JS validateStored (retry, another process signed in/out)
+    void validate_behind();   // JS launchCheck's background request
+    void sign_in();
+    void poll_sign_in();
+    void cancel_sign_in();
+    void open_sign_in_page();
+    void sign_out();
+    void recheck_quietly();
+    void check_cache_file();  // notices another process writing license.json
+
+    // ---- updates ----
+    void check_updates(bool automatic);
+    void download_update();
+    // Called by the runtime after ap_apply_staged_update replaced the files.
+    void mark_applied(const std::string &version);
+    // Applies a staged update now (filesystem only) and updates the view.
+    ApplyResult apply_now();
+    // "Update installed: restart After Effects to use v1.2.0", or "" (see ap_update_notice).
+    std::string notice() const;
+
+    // ---- timers ----
+    void tick();                 // runs every due timer
+    int64_t next_wake() const;   // absolute ms; INT64_MAX when nothing is scheduled
+
+    const LicenseView &license() const { return license_; }
+    const UpdateView &update() const { return update_; }
+    bool unlocked() const { return is_runnable(license_.status); }
+    const Settings &settings() const { return s_; }
+    const Paths &paths() const { return paths_; }
+    std::string computer();      // cached computer id
+    void set_cancel(const std::atomic<bool> *cancel) { cancel_ = cancel; }
+    bool sign_in_pending() const { return pending_.active; }
+
+    // Exposed for tests.
+    struct Check {
+        int64_t validated_at;
+        std::optional<int64_t> fresh_until;
+    };
+    std::optional<Check> trusted_check(const Json &cache);
+    std::optional<Json> read_cache();
+
+private:
+    struct Pending {
+        bool active = false;
+        std::string device_code;
+        std::string url;
+        int64_t expires_at = 0;
+        int64_t interval_ms = 3000;
+        int64_t poll_at = 0;
+    };
+    struct UpdateInfo {
+        std::string version, direction, change_log, download_url, sha256, signature;
+    };
+
+    ApiResult api(const std::string &suffix, const Json &body);
+    void set_state(Status status, const std::string &message = "", int grace_days = 0, const std::string &url = "");
+    void set_update(const UpdateView &view);
+    void log(int level, const std::string &message);
+    int64_t now() const { return env_.now_ms(); }
+
+    bool write_cache(const Json &cache);
+    void delete_cache();
+    void remember_cache_stamp();
+    bool is_fresh(const std::optional<Check> &check);
+    std::optional<int> grace_for(const Json &cache);
+    void apply_network_failure(const Json &cache, const std::string &error);
+    void apply_rejection(const ApiResult &err, const std::optional<Json> &cache);
+    void on_active(const std::string &token, const Json &json);
+    void unlock_from_cache(const Json &cache);
+    void schedule_recheck(const std::optional<Check> &check, int64_t delay = -2);
+    void clear_recheck() { recheck_at_ = -1; }
+    void stop_polling() { pending_ = Pending(); }
+    void sign_in_failed(const std::string &message);
+    Json token_body(const std::string &token);
+    std::optional<std::string> stored_token();
+
+    // updates
+    Json read_update_settings();
+    void write_update_settings(const Json &settings);
+    void schedule_first_update_check();
+    bool stage(const UpdateInfo &info, std::string &code, std::string &message);
+    bool acquire_lock();
+    void release_lock();
+
+    Settings s_;
+    Env env_;
+    Paths paths_;
+    std::function<void()> on_change_;
+    const std::atomic<bool> *cancel_ = nullptr;
+
+    LicenseView license_;
+    UpdateView update_;
+    Pending pending_;
+    std::string computer_id_;
+    std::string username_;
+    int64_t recheck_at_ = -1;
+    int64_t watch_at_ = -1;
+    std::optional<fsu::Stamp> cache_stamp_;  // license.json as this engine last wrote or read it
+
+    int64_t update_at_ = -1;
+    std::string failed_version_;             // automatic install of this version failed this session
+    std::optional<UpdateInfo> available_;    // last found update (notify / manual modes)
+    bool waiting_for_sign_in_ = false;       // automatic check skipped: no license token yet
+    bool lock_held_ = false;
+    std::string launch_token_;               // token unlocked at launch (validate_behind checks it)
+};
+
+// Replaces the installed <bundleId> folder's entries with the staged update
+// (apply.cpp). Filesystem only. version/error receive details.
+ApplyResult apply_staged_update(const Settings &settings, const Env &env, std::string *version, std::string *error);
+// Removes "(ap-old)" / "(ap-update)" folders left in the install folder by an
+// earlier apply (Windows keeps renamed loaded files until the next launch).
+void cleanup_install_leftovers(const Settings &settings);
+// The nearest ancestor of binary_path named exactly bundle_id, or "".
+std::string find_install_dir(const std::string &binary_path, const std::string &bundle_id);
+
+}  // namespace apn

package/native-runtime/src/fsutil.cpp

@@ -0,0 +1,291 @@
+#include "fsutil.hpp"
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <random>
+#include <system_error>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <io.h>
+#else
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+#ifdef __APPLE__
+#include <stdio.h>  // renamex_np
+#endif
+
+namespace fs = std::filesystem;
+
+namespace apn {
+namespace fsu {
+
+namespace {
+
+fs::path P(const std::string &s) {
+#if defined(_WIN32)
+    return fs::u8path(s);
+#else
+    return fs::path(s);
+#endif
+}
+
+std::string S(const fs::path &p) {
+#if defined(_WIN32)
+    auto u = p.u8string();
+    return std::string(u.begin(), u.end());
+#else
+    return p.string();
+#endif
+}
+
+std::string unique_suffix() {
+    static std::atomic<unsigned> counter{0};
+    std::random_device rd;
+    char buf[48];
+    std::snprintf(buf, sizeof buf, ".tmp-%08x%04x", (unsigned)rd(), (unsigned)(counter++ & 0xffff));
+    return buf;
+}
+
+bool write_plain(const std::string &path, const std::string &data, int mode) {
+#ifdef _WIN32
+    (void)mode;
+    std::ofstream f(P(path), std::ios::binary | std::ios::trunc);
+    if (!f) return false;
+    f.write(data.data(), (std::streamsize)data.size());
+    f.close();
+    return !f.fail();
+#else
+    int fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, mode);
+    if (fd < 0) return false;
+    ::fchmod(fd, (mode_t)mode);
+    const char *p = data.data();
+    size_t left = data.size();
+    while (left) {
+        ssize_t n = ::write(fd, p, left);
+        if (n < 0) {
+            if (errno == EINTR) continue;
+            ::close(fd);
+            return false;
+        }
+        p += n;
+        left -= (size_t)n;
+    }
+    bool ok = ::fsync(fd) == 0 || errno == EINVAL;
+    return ::close(fd) == 0 && ok;
+#endif
+}
+
+}  // namespace
+
+std::string join(const std::string &a, const std::string &b) { return S(P(a) / P(b)); }
+std::string parent(const std::string &path) { return S(P(path).parent_path()); }
+std::string basename(const std::string &path) {
+    fs::path p = P(path);
+    if (!p.has_filename()) p = p.parent_path();
+    return S(p.filename());
+}
+
+bool exists(const std::string &path) {
+    std::error_code ec;
+    return fs::exists(fs::symlink_status(P(path), ec)) && !ec;
+}
+
+bool is_dir(const std::string &path) {
+    std::error_code ec;
+    return fs::is_directory(P(path), ec);
+}
+
+bool mkdirs(const std::string &path) {
+    std::error_code ec;
+    fs::create_directories(P(path), ec);
+    return is_dir(path);
+}
+
+bool remove_all(const std::string &path) {
+    std::error_code ec;
+    fs::remove_all(P(path), ec);
+    return !ec;
+}
+
+bool remove_file(const std::string &path) {
+    std::error_code ec;
+    fs::remove(P(path), ec);
+    return !ec;
+}
+
+bool rename(const std::string &from, const std::string &to) {
+    std::error_code ec;
+    fs::rename(P(from), P(to), ec);
+    return !ec;
+}
+
+std::vector<std::string> list(const std::string &dir) {
+    std::vector<std::string> out;
+    std::error_code ec;
+    for (fs::directory_iterator it(P(dir), ec), end; !ec && it != end; it.increment(ec)) {
+        out.push_back(S(it->path().filename()));
+    }
+    std::sort(out.begin(), out.end());
+    return out;
+}
+
+std::optional<std::string> read(const std::string &path, uint64_t max_bytes) {
+    std::ifstream f(P(path), std::ios::binary);
+    if (!f) return std::nullopt;
+    std::string data;
+    char buf[65536];
+    while (f) {
+        f.read(buf, sizeof buf);
+        data.append(buf, (size_t)f.gcount());
+        if (data.size() > max_bytes) return std::nullopt;
+    }
+    if (f.bad()) return std::nullopt;
+    return data;
+}
+
+bool write_atomic(const std::string &path, const std::string &data, bool private_file) {
+    if (!mkdirs(parent(path))) return false;
+    std::string tmp = path + unique_suffix();
+    if (!write_plain(tmp, data, private_file ? 0600 : 0644)) {
+        remove_file(tmp);
+        return false;
+    }
+    if (!rename(tmp, path)) {
+        // Windows can refuse to replace a file another process has open; retry once after deleting.
+        remove_file(path);
+        if (!rename(tmp, path)) {
+            remove_file(tmp);
+            return false;
+        }
+    }
+    return true;
+}
+
+Excl write_exclusive(const std::string &path, const std::string &data) {
+    if (!mkdirs(parent(path))) return Excl::Error;
+#ifdef _WIN32
+    HANDLE h = CreateFileW(P(path).c_str(), GENERIC_WRITE, 0, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (h == INVALID_HANDLE_VALUE) return GetLastError() == ERROR_FILE_EXISTS ? Excl::Exists : Excl::Error;
+    DWORD written = 0;
+    BOOL ok = WriteFile(h, data.data(), (DWORD)data.size(), &written, nullptr);
+    CloseHandle(h);
+    return ok && written == data.size() ? Excl::Ok : Excl::Error;
+#else
+    int fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0644);
+    if (fd < 0) return errno == EEXIST ? Excl::Exists : Excl::Error;
+    ssize_t n = ::write(fd, data.data(), data.size());
+    ::close(fd);
+    return n == (ssize_t)data.size() ? Excl::Ok : Excl::Error;
+#endif
+}
+
+bool write_file(const std::string &path, const std::string &data, bool executable) {
+    if (!mkdirs(parent(path))) return false;
+    return write_plain(path, data, executable ? 0755 : 0644);
+}
+
+std::optional<Stamp> stamp(const std::string &path) {
+#ifdef _WIN32
+    std::error_code ec;
+    auto size = fs::file_size(P(path), ec);
+    if (ec) return std::nullopt;
+    auto t = fs::last_write_time(P(path), ec);
+    if (ec) return std::nullopt;
+    Stamp s;
+    s.size = size;
+    s.mtime_ns = (int64_t)std::chrono::duration_cast<std::chrono::nanoseconds>(t.time_since_epoch()).count();
+    return s;
+#else
+    struct stat st;
+    if (::stat(path.c_str(), &st) != 0) return std::nullopt;
+    Stamp s;
+    s.size = (uint64_t)st.st_size;
+#ifdef __APPLE__
+    s.mtime_ns = (int64_t)st.st_mtimespec.tv_sec * 1000000000LL + st.st_mtimespec.tv_nsec;
+#else
+    s.mtime_ns = (int64_t)st.st_mtim.tv_sec * 1000000000LL + st.st_mtim.tv_nsec;
+#endif
+    s.inode = (uint64_t)st.st_ino;
+    return s;
+#endif
+}
+
+int64_t age_ms(const std::string &path, int64_t now_ms) {
+#ifdef _WIN32
+    WIN32_FILE_ATTRIBUTE_DATA d;
+    if (!GetFileAttributesExW(P(path).c_str(), GetFileExInfoStandard, &d)) return -1;
+    ULARGE_INTEGER t;
+    t.LowPart = d.ftLastWriteTime.dwLowDateTime;
+    t.HighPart = d.ftLastWriteTime.dwHighDateTime;
+    int64_t unix_ms = (int64_t)(t.QuadPart / 10000ULL) - 11644473600000LL;
+    return now_ms - unix_ms;
+#else
+    struct stat st;
+    if (::stat(path.c_str(), &st) != 0) return -1;
+    return now_ms - (int64_t)st.st_mtime * 1000;
+#endif
+}
+
+bool copy_tree(const std::string &from, const std::string &to, std::string *error) {
+    std::error_code ec;
+    fs::path src = P(from), dst = P(to);
+    fs::create_directories(dst, ec);
+    if (ec) { if (error) *error = "cannot create " + basename(to); return false; }
+    for (fs::recursive_directory_iterator it(src, ec), end; !ec && it != end; it.increment(ec)) {
+        fs::path rel = it->path().lexically_relative(src);
+        fs::path target = dst / rel;
+        auto st = it->symlink_status(ec);
+        if (ec) break;
+        if (fs::is_symlink(st)) { if (error) *error = "symbolic link in update: " + S(rel); return false; }
+        if (fs::is_directory(st)) {
+            fs::create_directories(target, ec);
+        } else if (fs::is_regular_file(st)) {
+            fs::copy_file(it->path(), target, fs::copy_options::overwrite_existing, ec);
+#ifndef _WIN32
+            if (!ec) {
+                bool exec = (st.permissions() & fs::perms::owner_exec) != fs::perms::none;
+                fs::permissions(target, exec ? (fs::perms)0755 : (fs::perms)0644, ec);
+            }
+#endif
+        } else {
+            if (error) *error = "unsupported file type: " + S(rel);
+            return false;
+        }
+        if (ec) break;
+    }
+    if (ec) { if (error) *error = "copy failed: " + ec.message(); return false; }
+    return true;
+}
+
+static std::atomic<bool> swap_disabled{false};
+void test_disable_swap(bool disabled) { swap_disabled.store(disabled); }
+
+bool swap(const std::string &a, const std::string &b) {
+    if (swap_disabled.load()) return false;
+#ifdef __APPLE__
+    return ::renamex_np(a.c_str(), b.c_str(), RENAME_SWAP) == 0;
+#else
+    (void)a;
+    (void)b;
+    return false;
+#endif
+}
+
+bool dir_writable(const std::string &dir) {
+    if (!is_dir(dir)) return false;
+    std::string probe = join(dir, "(ap-write-test)" + unique_suffix());
+    if (write_exclusive(probe, "") != Excl::Ok) return false;
+    remove_file(probe);
+    return true;
+}
+
+}  // namespace fsu
+}  // namespace apn

package/native-runtime/src/fsutil.hpp

@@ -0,0 +1,57 @@
+// UTF-8 path helpers over std::filesystem. Never throw; report failure.
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace apn {
+namespace fsu {
+
+std::string join(const std::string &a, const std::string &b);
+std::string parent(const std::string &path);
+std::string basename(const std::string &path);
+
+bool exists(const std::string &path);
+bool is_dir(const std::string &path);
+bool mkdirs(const std::string &path);
+bool remove_all(const std::string &path);
+bool remove_file(const std::string &path);
+bool rename(const std::string &from, const std::string &to);
+std::vector<std::string> list(const std::string &dir);  // entry names, sorted
+
+std::optional<std::string> read(const std::string &path, uint64_t max_bytes = 16 * 1024 * 1024);
+// temp file + rename. private_file: 0600 on POSIX (files that hold a token).
+bool write_atomic(const std::string &path, const std::string &data, bool private_file);
+enum class Excl { Ok, Exists, Error };
+// O_CREAT|O_EXCL (the JS runtime's flag "wx").
+Excl write_exclusive(const std::string &path, const std::string &data);
+// mode 0755 when executable on POSIX.
+bool write_file(const std::string &path, const std::string &data, bool executable);
+
+// Size and modification time; nullopt when missing. Used to notice another
+// process writing a shared cache file.
+struct Stamp {
+    uint64_t size = 0;
+    int64_t mtime_ns = 0;
+    uint64_t inode = 0;  // an atomic replace with the same size within one mtime tick still differs
+    bool operator==(const Stamp &o) const { return size == o.size && mtime_ns == o.mtime_ns && inode == o.inode; }
+    bool operator!=(const Stamp &o) const { return !(*this == o); }
+};
+std::optional<Stamp> stamp(const std::string &path);
+int64_t age_ms(const std::string &path, int64_t now_ms);  // -1 when missing
+
+// Copies a directory tree (files and directories only; refuses symlinks),
+// keeping the POSIX executable bit.
+bool copy_tree(const std::string &from, const std::string &to, std::string *error);
+// Atomically exchanges two paths (macOS renamex_np RENAME_SWAP). false when
+// unsupported or failed; the caller falls back to two renames.
+bool swap(const std::string &a, const std::string &b);
+// Tests: exercise the rename fallback (the Windows path) on macOS.
+void test_disable_swap(bool disabled);
+// True when this process may create, rename and delete entries in dir.
+bool dir_writable(const std::string &dir);
+
+}  // namespace fsu
+}  // namespace apn