@entelligentsia/forgecli 0.7.6 → 0.7.9

package/node_modules/koffi/src/koffi/src/util.hh

@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#pragma once
+
+#include "lib/native/base/base.hh"
+#include "ffi.hh"
+
+#include <napi.h>
+
+namespace K {
+
+extern const napi_type_tag TypeInfoMarker;
+extern const napi_type_tag CastMarker;
+extern const napi_type_tag MagicUnionMarker;
+
+class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
+    const TypeInfo *type;
+
+    Napi::Reference<Napi::Symbol> active_symbol;
+    Size active_idx = -1;
+
+    HeapArray<uint8_t> raw;
+
+public:
+    static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
+
+    MagicUnion(const Napi::CallbackInfo &info);
+
+    const TypeInfo *GetType() { return type; }
+    const RecordMember *GetMember() const { return (active_idx >= 0) ? &type->members[active_idx] : nullptr; }
+
+    void SetRaw(const uint8_t *ptr);
+    const uint8_t *GetRaw() const { return raw.ptr; }
+
+private:
+    Napi::Value Getter(const Napi::CallbackInfo &info);
+    void Setter(const Napi::CallbackInfo &info, const Napi::Value &value);
+};
+
+template <typename T, typename... Args>
+void ThrowError(Napi::Env env, const char *msg, Args... args)
+{
+    char buf[1024];
+    Fmt(buf, msg, args...);
+
+    auto err = T::New(env, buf);
+    err.ThrowAsJavaScriptException();
+}
+
+static inline bool IsInteger(const TypeInfo *type)
+{
+    bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
+                    (int)type->primitive <= (int)PrimitiveKind::UInt64);
+    return integer;
+}
+
+static inline bool IsFloat(const TypeInfo *type)
+{
+    bool fp = (type->primitive == PrimitiveKind::Float32 ||
+               type->primitive == PrimitiveKind::Float64);
+    return fp;
+}
+
+static inline bool IsRegularSize(Size size, Size max)
+{
+    bool regular = (size <= max && !(size & (size - 1)));
+    return regular;
+}
+
+int ResolveDirections(Span<const char> str);
+const TypeInfo *ResolveType(Napi::Value value, int *out_directions = nullptr);
+const TypeInfo *ResolveType(Napi::Env env, Span<const char> str);
+
+TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
+
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type);
+
+bool CanPassType(const TypeInfo *type, int directions);
+bool CanReturnType(const TypeInfo *type);
+bool CanStoreType(const TypeInfo *type);
+
+// Can be slow, only use for error messages
+const char *GetValueType(const InstanceData *instance, Napi::Value value);
+
+void SetValueTag(Napi::Value value, const void *marker);
+bool CheckValueTag(Napi::Value value, const void *marker);
+
+static inline bool IsNullOrUndefined(Napi::Value value)
+{
+    return value.IsNull() || value.IsUndefined();
+}
+
+static inline bool IsObject(Napi::Value value)
+{
+    return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
+}
+
+static inline bool IsRawBuffer(Napi::Value value)
+{
+    return value.IsTypedArray() || value.IsArrayBuffer();
+}
+
+static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
+{
+    if (value.IsBuffer()) {
+        void *ptr = nullptr;
+        size_t length = 0;
+
+        // Assume it works
+        napi_get_buffer_info(value.Env(), value, &ptr, &length);
+
+        return MakeSpan((uint8_t *)ptr, (Size)length);
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+
+        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+    }
+
+    K_UNREACHABLE();
+}
+
+int GetTypedArrayType(const TypeInfo *type);
+
+template <typename T>
+T GetNumber(Napi::Value value)
+{
+    K_ASSERT(value.IsNumber() || value.IsBigInt());
+
+    if (value.IsNumber()) [[likely]] {
+        return (T)value.As<Napi::Number>().DoubleValue();
+    } else if (value.IsBigInt()) {
+        Napi::BigInt bigint = value.As<Napi::BigInt>();
+
+        bool lossless;
+        return (T)bigint.Uint64Value(&lossless);
+    }
+
+    K_UNREACHABLE();
+}
+
+template <typename T>
+Size NullTerminatedLength(const T *ptr)
+{
+    Size len = 0;
+    while (ptr[len]) {
+        len++;
+    }
+    return len;
+}
+template <typename T>
+Size NullTerminatedLength(const T *ptr, Size max)
+{
+    Size len = 0;
+    while (len < max && ptr[len]) {
+        len++;
+    }
+    return len;
+}
+
+Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
+static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
+    { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
+
+Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
+void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type);
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
+void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
+
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
+
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+
+static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
+{
+    if (value <= 9007199254740992ll && value >= -9007199254740992ll) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, value);
+    }
+}
+
+static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
+{
+    if (value <= 9007199254740992ull) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, value);
+    }
+}
+
+static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
+{
+    Napi::Env env = obj.Env();
+
+    napi_value result;
+    napi_status status = napi_get_all_property_names(env, obj, napi_key_own_only,
+                                                     (napi_key_filter)(napi_key_enumerable | napi_key_skip_symbols),
+                                                     napi_key_numbers_to_strings, &result);
+    K_ASSERT(status == napi_ok);
+
+    return Napi::Array(env, result);
+}
+
+Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
+
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
+
+int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
+
+void DumpMemory(const char *type, Span<const uint8_t> bytes);
+
+}

package/node_modules/koffi/src/koffi/src/uv.cc

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: MIT
+
+#include "uv.hh"
+#include "util.hh"
+
+#include <uv.h>
+
+namespace K {
+
+Napi::Function PollHandle::Define(Napi::Env env)
+{
+    return DefineClass(env, "PollHandle", {
+        InstanceMethod("start", &PollHandle::Start),
+        InstanceMethod("stop", &PollHandle::Stop),
+        InstanceMethod("close", &PollHandle::Close),
+        InstanceMethod("unref", &PollHandle::Unref),
+        InstanceMethod("ref", &PollHandle::Ref)
+    });
+}
+
+PollHandle::PollHandle(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<PollHandle>(info), env(info.Env())
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        ThrowError<Napi::Error>(env, "Expected 1 argument, got %1", info.Length());
+        return;
+    }
+    if (!info[0].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
+        return;
+    }
+
+    int fd = info[0].As<Napi::Number>().Int32Value();
+
+    uv_loop_t *loop = nullptr;
+    if (napi_get_uv_event_loop(env, &loop) != napi_ok || !loop) {
+        ThrowError<Napi::Error>(env, "napi_get_uv_event_loop() failed");
+        return;
+    }
+
+    // We would store it inside the class, but the definition of uv_poll_t involves windows.h...
+    // and we won't want that on Windows. Heap allocation it is!
+    // Also, it may have to outlive the object, because uv_close() is asynchronous.
+    handle = new uv_poll_t();
+
+    if (int ret = uv_poll_init_socket(loop, handle, (uv_os_sock_t)fd); ret != 0) {
+        ThrowError<Napi::Error>(env, "Failed to init UV poll: %1", uv_strerror(ret));
+        return;
+    }
+
+    handle->data = this;
+}
+
+void PollHandle::Start(const Napi::CallbackInfo &info)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    bool has_opts = (info.Length() >= 2 && info[0].IsObject());
+
+    if (info.Length() < 1u + has_opts) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", info.Length());
+        return;
+    }
+    if (!info[0u + has_opts].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[0u + has_opts]));
+        return;
+    }
+
+    int events = 0;
+    Napi::Function cb = info[0 + has_opts].As<Napi::Function>();
+
+    if (has_opts) {
+        Napi::Object opts = has_opts ? info[0].As<Napi::Object>() : Napi::Object::New(env);
+
+        events |= opts.Get("readable").ToBoolean() ? UV_READABLE : 0;
+        events |= opts.Get("writable").ToBoolean() ? UV_WRITABLE : 0;
+        events |= opts.Get("disconnect").ToBoolean() ? UV_DISCONNECT : 0;
+    } else {
+        events = UV_READABLE;
+    }
+
+    callback.Reset(cb, 1);
+
+    if (int ret = uv_poll_start(handle, events, &PollHandle::OnPoll); ret != 0) {
+        callback.Reset();
+        ThrowError<Napi::Error>(env, "Failed to start UV poll: %1", uv_strerror(ret));
+    }
+}
+
+void PollHandle::Stop(const Napi::CallbackInfo &)
+{
+    uv_poll_stop(handle);
+    callback.Reset();
+}
+
+void PollHandle::Close(const Napi::CallbackInfo &)
+{
+    Close();
+    callback.Reset();
+}
+
+void PollHandle::Ref(const Napi::CallbackInfo &)
+{
+    uv_ref((uv_handle_t *)handle);
+}
+
+void PollHandle::Unref(const Napi::CallbackInfo &)
+{
+    uv_unref((uv_handle_t *)handle);
+}
+
+void PollHandle::Close()
+{
+    if (!handle)
+        return;
+
+    const auto release = [](uv_handle_t *ptr) {
+        uv_poll_t *handle = (uv_poll_t *)ptr;
+        delete handle;
+    };
+
+    uv_poll_stop(handle);
+    uv_close((uv_handle_t *)handle, release);
+
+    handle = nullptr;
+}
+
+void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
+{
+    PollHandle *poll = (PollHandle *)h->data;
+
+    if (poll->callback.IsEmpty()) [[unlikely]]
+        return;
+
+    Napi::Env env = poll->env;
+    Napi::HandleScope scope(env);
+
+    Napi::Object obj = Napi::Object::New(env);
+
+    obj.Set("readable", !!(events & UV_READABLE));
+    obj.Set("writable", !!(events & UV_WRITABLE));
+    obj.Set("disconnect", !!(events & UV_DISCONNECT));
+
+    napi_value args[] = { Napi::Number::New(env, status), obj };
+    poll->callback.Call(poll->Value(), K_LEN(args), args);
+}
+
+Napi::Value Poll(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    bool has_opts = (info.Length() >= 3 && info[1].IsObject());
+
+    if (info.Length() < 2u + has_opts) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 to 3 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    if (!info[0].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (!info[1 + has_opts].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[1 + has_opts]));
+        return env.Null();
+    }
+
+    int fd = info[0].As<Napi::Number>().Int32Value();
+
+    Napi::Function ctor = PollHandle::Define(env);
+    Napi::Object inst = ctor.New({ Napi::Number::New(env, fd) });
+    Napi::Function start = inst.Get("start").As<Napi::Function>();
+
+    if (env.IsExceptionPending()) [[unlikely]]
+        return env.Null();
+
+    if (has_opts) {
+        Napi::Value opts = info[1];
+        Napi::Function cb = info[2].As<Napi::Function>();
+
+        start.Call(inst, { opts, cb });
+    } else {
+        Napi::Function cb = info[1].As<Napi::Function>();
+        start.Call(inst, { cb });
+    }
+
+    return inst;
+}
+
+}

package/node_modules/koffi/src/koffi/src/uv.def

@@ -0,0 +1,10 @@
+NAME NODE.EXE
+EXPORTS
+uv_close
+uv_ref
+uv_unref
+uv_strerror
+uv_poll_init
+uv_poll_init_socket
+uv_poll_start
+uv_poll_stop

package/node_modules/koffi/src/koffi/src/uv.hh

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "lib/native/base/base.hh"
+
+#include <napi.h>
+
+struct uv_poll_s;
+typedef struct uv_poll_s uv_poll_t;
+
+namespace K {
+
+class PollHandle: public Napi::ObjectWrap<PollHandle> {
+    Napi::Env env = nullptr;
+
+    uv_poll_t *handle = nullptr;
+    Napi::FunctionReference callback;
+
+public:
+    static Napi::Function Define(Napi::Env env);
+
+    PollHandle(const Napi::CallbackInfo &info);
+    ~PollHandle() { Close(); }
+
+    void Start(const Napi::CallbackInfo &info);
+    void Stop(const Napi::CallbackInfo &info);
+    void Close(const Napi::CallbackInfo &info);
+    void Ref(const Napi::CallbackInfo &info);
+    void Unref(const Napi::CallbackInfo &info);
+
+private:
+    void Close();
+
+    static void OnPoll(uv_poll_t *handle, int status, int events);
+};
+
+Napi::Value Poll(const Napi::CallbackInfo &info);
+
+}

package/node_modules/koffi/src/koffi/src/win32.cc

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#if defined(_WIN32)
+
+#include "util.hh"
+#include "win32.hh"
+
+#if !defined(NOMINMAX)
+    #define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN)
+    #define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <ntsecapi.h>
+#include <processthreadsapi.h>
+
+namespace K {
+
+const HashMap<int, const char *> WindowsMachineNames = {
+    { 0x184, "Alpha AXP, 32-bit" },
+    { 0x284, "Alpha 64" },
+    { 0x1d3, "Matsushita AM33" },
+    { 0x8664, "AMD x64" },
+    { 0x1c0, "ARM little endian" },
+    { 0xaa64, "ARM64 little endian" },
+    { 0x1c4, "ARM Thumb-2 little endian" },
+    { 0x284, "AXP 64" },
+    { 0xebc, "EFI byte code" },
+    { 0x14c, "Intel 386+" },
+    { 0x200, "Intel Itanium" },
+    { 0x6232, "LoongArch 32-bit" },
+    { 0x6264, "LoongArch 64-bit" },
+    { 0x9041, "Mitsubishi M32R little endian" },
+    { 0x266, "MIPS16" },
+    { 0x366, "MIPS with FPU" },
+    { 0x466, "MIPS16 with FPU" },
+    { 0x1f0, "Power PC little endian" },
+    { 0x1f1, "Power PC with FP support" },
+    { 0x166, "MIPS little endian" },
+    { 0x5032, "RISC-V 32-bit" },
+    { 0x5064, "RISC-V 64-bit" },
+    { 0x5128, "RISC-V 128-bit" },
+    { 0x1a2, "Hitachi SH3" },
+    { 0x1a3, "Hitachi SH3 DSP" },
+    { 0x1a6, "Hitachi SH4" },
+    { 0x1a8, "Hitachi SH5" },
+    { 0x1c2, "Thumb" },
+    { 0x169, "MIPS little-endian WCE v2" }
+};
+
+HANDLE LoadWindowsLibrary(Napi::Env env, Span<const char> path)
+{
+    BlockAllocator temp_alloc;
+
+    Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, path.len + 1);
+
+    if (ConvertUtf8ToWin32Wide(path, filename_w) < 0) {
+        ThrowError<Napi::Error>(env, "Invalid path string");
+        return nullptr;
+    }
+
+    HMODULE module = LoadLibraryW(filename_w.ptr);
+
+    if (!module) {
+        DWORD flags = LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR;
+
+        Span<const char> filename = NormalizePath(path, GetWorkingDirectory(), &temp_alloc);
+        Span<wchar_t> filename_w = AllocateSpan<wchar_t>(&temp_alloc, filename.len + 1);
+
+        if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0) {
+            ThrowError<Napi::Error>(env, "Invalid path string");
+            return nullptr;
+        }
+
+        module = LoadLibraryExW(filename_w.ptr, nullptr, flags);
+    }
+
+    if (!module) {
+        if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
+            int process = GetSelfMachine();
+            int dll = GetDllMachine(filename_w.ptr);
+
+            if (process >= 0 && dll >= 0 && dll != process) {
+                ThrowError<Napi::Error>(env, "Cannot load '%1' DLL in '%2' process",
+                                        WindowsMachineNames.FindValue(dll, "Unknown"),
+                                        WindowsMachineNames.FindValue(process, "Unknown"));
+                return nullptr;
+            }
+        }
+
+        ThrowError<Napi::Error>(env, "Failed to load shared library: %1", GetWin32ErrorString());
+        return nullptr;
+    }
+
+    return module;
+}
+
+// Fails silently on purpose
+static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
+{
+    OVERLAPPED ov = {};
+    DWORD read;
+
+    ov.Offset = offset & 0x7FFFFFFFu;
+
+    if (offset < 0)
+        return false;
+    if (!ReadFile(h, buf, (DWORD)len, &read, &ov))
+        return false;
+    if (read != (DWORD)len)
+        return false;
+
+    return true;
+}
+
+static int GetFileMachine(HANDLE h, bool check_dll)
+{
+    PE_DOS_HEADER dos = {};
+    PE_NT_HEADERS nt = {};
+
+    if (!ReadAt(h, 0, &dos, K_SIZE(dos)))
+        goto generic;
+    if (!ReadAt(h, dos.e_lfanew, &nt, K_SIZE(nt)))
+        goto generic;
+
+    if (dos.e_magic != 0x5A4D) // MZ
+        goto generic;
+    if (nt.Signature != 0x00004550) // PE\0\0
+        goto generic;
+    if (check_dll && !(nt.FileHeader.Characteristics & IMAGE_FILE_DLL))
+        goto generic;
+
+    return (int)nt.FileHeader.Machine;
+
+generic:
+    LogError("Invalid or forbidden %1 file: %2", check_dll ? "DLL" : "executable", GetWin32ErrorString());
+    return -1;
+}
+
+int GetSelfMachine()
+{
+    const char *filename = GetApplicationExecutable();
+
+    HANDLE h;
+    if (IsWin32Utf8()) {
+        h = CreateFileA(filename, GENERIC_READ,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                        nullptr, OPEN_EXISTING, 0, nullptr);
+    } else {
+        wchar_t filename_w[4096];
+        if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
+            return -1;
+
+        h = CreateFileW(filename_w, GENERIC_READ,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                        nullptr, OPEN_EXISTING, 0, nullptr);
+    }
+    if (h == INVALID_HANDLE_VALUE) {
+        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
+        return -1;
+    }
+    K_DEFER { CloseHandle(h); };
+
+    return GetFileMachine(h, false);
+}
+
+int GetDllMachine(const wchar_t *filename)
+{
+    HANDLE h = CreateFileW((LPCWSTR)filename, GENERIC_READ,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                           nullptr, OPEN_EXISTING, 0, nullptr);
+    if (h == INVALID_HANDLE_VALUE) {
+        LogError("Cannot open '%1': %2", filename, GetWin32ErrorString());
+        return -1;
+    }
+    K_DEFER { CloseHandle(h); };
+
+    return GetFileMachine(h, true);
+}
+
+extern "C" int __cdecl SehHandler(void *ptr, void *, void *ctx, void *)
+{
+    EXCEPTION_RECORD *rec = (EXCEPTION_RECORD *)ptr;
+
+    if (!(rec->ExceptionFlags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))) {
+        EXCEPTION_POINTERS ep = { rec, (CONTEXT *)ctx };
+        UnhandledExceptionFilter(&ep);
+        ExitProcess(rec->ExceptionCode);
+    }
+
+    return ExceptionContinueSearch;
+}
+
+}
+
+#endif