smartcard 1.0.46 → 2.0.1

package/src/pcsc_card.cpp

@@ -0,0 +1,248 @@
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+#include <cstring>
+
+Napi::FunctionReference PCSCCard::constructor;
+
+Napi::Object PCSCCard::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Card", {
+        InstanceAccessor("protocol", &PCSCCard::GetProtocolValue, nullptr),
+        InstanceAccessor("connected", &PCSCCard::GetConnectedValue, nullptr),
+        InstanceAccessor("atr", &PCSCCard::GetAtr, nullptr),
+        InstanceMethod("transmit", &PCSCCard::Transmit),
+        InstanceMethod("control", &PCSCCard::Control),
+        InstanceMethod("getStatus", &PCSCCard::GetStatus),
+        InstanceMethod("disconnect", &PCSCCard::Disconnect),
+        InstanceMethod("reconnect", &PCSCCard::Reconnect),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Card", func);
+    return exports;
+}
+
+Napi::Object PCSCCard::NewInstance(Napi::Env env, SCARDHANDLE card,
+                                    DWORD protocol, const std::string& readerName) {
+    Napi::Object obj = constructor.New({});
+    PCSCCard* cardObj = Napi::ObjectWrap<PCSCCard>::Unwrap(obj);
+    cardObj->card_ = card;
+    cardObj->protocol_ = protocol;
+    cardObj->readerName_ = readerName;
+    cardObj->connected_ = true;
+    return obj;
+}
+
+PCSCCard::PCSCCard(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCCard>(info),
+      card_(0),
+      protocol_(SCARD_PROTOCOL_UNDEFINED),
+      connected_(false) {
+    // Properties set via NewInstance
+}
+
+PCSCCard::~PCSCCard() {
+    if (connected_ && card_ != 0) {
+        SCardDisconnect(card_, SCARD_LEAVE_CARD);
+        connected_ = false;
+        card_ = 0;
+    }
+}
+
+Napi::Value PCSCCard::GetProtocolValue(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), protocol_);
+}
+
+Napi::Value PCSCCard::GetConnectedValue(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), connected_);
+}
+
+Napi::Value PCSCCard::GetAtr(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        return env.Null();
+    }
+
+    // Get ATR via SCardStatus
+    DWORD readerLen = 0;
+    DWORD state = 0;
+    DWORD protocol = 0;
+    BYTE atr[MAX_ATR_SIZE];
+    DWORD atrLen = sizeof(atr);
+
+    LONG result = SCardStatus(card_, nullptr, &readerLen, &state, &protocol, atr, &atrLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        return env.Null();
+    }
+
+    return Napi::Buffer<uint8_t>::Copy(env, atr, atrLen);
+}
+
+Napi::Value PCSCCard::Transmit(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Expected command buffer").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::vector<uint8_t> sendBuffer;
+
+    if (info[0].IsBuffer()) {
+        Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+        sendBuffer.assign(buffer.Data(), buffer.Data() + buffer.Length());
+    } else if (info[0].IsArray()) {
+        Napi::Array arr = info[0].As<Napi::Array>();
+        sendBuffer.reserve(arr.Length());
+        for (uint32_t i = 0; i < arr.Length(); i++) {
+            sendBuffer.push_back(static_cast<uint8_t>(arr.Get(i).As<Napi::Number>().Uint32Value()));
+        }
+    } else {
+        Napi::TypeError::New(env, "Expected Buffer or Array").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Create promise for async transmit
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    TransmitWorker* worker = new TransmitWorker(
+        env, card_, protocol_, sendBuffer, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCCard::Control(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected control code").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD controlCode = info[0].As<Napi::Number>().Uint32Value();
+
+    std::vector<uint8_t> sendBuffer;
+    if (info.Length() > 1) {
+        if (info[1].IsBuffer()) {
+            Napi::Buffer<uint8_t> buffer = info[1].As<Napi::Buffer<uint8_t>>();
+            sendBuffer.assign(buffer.Data(), buffer.Data() + buffer.Length());
+        } else if (info[1].IsArray()) {
+            Napi::Array arr = info[1].As<Napi::Array>();
+            sendBuffer.reserve(arr.Length());
+            for (uint32_t i = 0; i < arr.Length(); i++) {
+                sendBuffer.push_back(static_cast<uint8_t>(arr.Get(i).As<Napi::Number>().Uint32Value()));
+            }
+        }
+    }
+
+    // Create promise for async control
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    ControlWorker* worker = new ControlWorker(
+        env, card_, controlCode, sendBuffer, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCCard::GetStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD readerLen = 0;
+    DWORD state = 0;
+    DWORD protocol = 0;
+    BYTE atr[MAX_ATR_SIZE];
+    DWORD atrLen = sizeof(atr);
+
+    // First call to get reader name length
+    LONG result = SCardStatus(card_, nullptr, &readerLen, &state, &protocol, atr, &atrLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object status = Napi::Object::New(env);
+    status.Set("state", Napi::Number::New(env, state));
+    status.Set("protocol", Napi::Number::New(env, protocol));
+    status.Set("atr", Napi::Buffer<uint8_t>::Copy(env, atr, atrLen));
+
+    return status;
+}
+
+Napi::Value PCSCCard::Disconnect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        return env.Undefined();
+    }
+
+    DWORD disposition = SCARD_LEAVE_CARD;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        disposition = info[0].As<Napi::Number>().Uint32Value();
+    }
+
+    LONG result = SCardDisconnect(card_, disposition);
+    connected_ = false;
+    card_ = 0;
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCCard::Reconnect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!connected_) {
+        Napi::Error::New(env, "Card is not connected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    DWORD shareMode = SCARD_SHARE_SHARED;
+    DWORD preferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
+    DWORD initialization = SCARD_LEAVE_CARD;
+
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        shareMode = info[0].As<Napi::Number>().Uint32Value();
+    }
+    if (info.Length() > 1 && info[1].IsNumber()) {
+        preferredProtocols = info[1].As<Napi::Number>().Uint32Value();
+    }
+    if (info.Length() > 2 && info[2].IsNumber()) {
+        initialization = info[2].As<Napi::Number>().Uint32Value();
+    }
+
+    DWORD activeProtocol = 0;
+    LONG result = SCardReconnect(card_, shareMode, preferredProtocols, initialization, &activeProtocol);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    protocol_ = activeProtocol;
+    return Napi::Number::New(env, activeProtocol);
+}

package/src/pcsc_card.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <napi.h>
+#include <string>
+#include <vector>
+#include "platform/pcsc.h"
+
+class PCSCCard : public Napi::ObjectWrap<PCSCCard> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Env env, SCARDHANDLE card,
+                                     DWORD protocol, const std::string& readerName);
+
+    PCSCCard(const Napi::CallbackInfo& info);
+    ~PCSCCard();
+
+    // Accessors
+    SCARDHANDLE GetHandle() const { return card_; }
+    DWORD GetProtocol() const { return protocol_; }
+    bool IsConnected() const { return connected_; }
+
+private:
+    static Napi::FunctionReference constructor;
+
+    SCARDHANDLE card_;
+    DWORD protocol_;
+    std::string readerName_;
+    bool connected_;
+
+    // JavaScript-exposed methods
+    Napi::Value Transmit(const Napi::CallbackInfo& info);
+    Napi::Value Control(const Napi::CallbackInfo& info);
+    Napi::Value GetStatus(const Napi::CallbackInfo& info);
+    Napi::Value Disconnect(const Napi::CallbackInfo& info);
+    Napi::Value Reconnect(const Napi::CallbackInfo& info);
+
+    // Getters
+    Napi::Value GetProtocolValue(const Napi::CallbackInfo& info);
+    Napi::Value GetConnectedValue(const Napi::CallbackInfo& info);
+    Napi::Value GetAtr(const Napi::CallbackInfo& info);
+};

package/src/pcsc_context.cpp

@@ -0,0 +1,224 @@
+#include "pcsc_context.h"
+#include "pcsc_reader.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+#include <cstring>
+
+Napi::FunctionReference PCSCContext::constructor;
+
+Napi::Object PCSCContext::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Context", {
+        InstanceMethod("listReaders", &PCSCContext::ListReaders),
+        InstanceMethod("waitForChange", &PCSCContext::WaitForChange),
+        InstanceMethod("cancel", &PCSCContext::Cancel),
+        InstanceMethod("close", &PCSCContext::Close),
+        InstanceAccessor("isValid", &PCSCContext::GetIsValid, nullptr),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Context", func);
+    return exports;
+}
+
+Napi::Object PCSCContext::NewInstance(Napi::Env env) {
+    return constructor.New({});
+}
+
+PCSCContext::PCSCContext(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCContext>(info), context_(0), valid_(false) {
+
+    Napi::Env env = info.Env();
+
+    // Establish PC/SC context
+    LONG result = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, &context_);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return;
+    }
+
+    valid_ = true;
+}
+
+PCSCContext::~PCSCContext() {
+    if (valid_ && context_ != 0) {
+        SCardReleaseContext(context_);
+        valid_ = false;
+        context_ = 0;
+    }
+}
+
+Napi::Value PCSCContext::ListReaders(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        Napi::Error::New(env, "Context is not valid").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // First call to get buffer size
+    DWORD readersLen = 0;
+    LONG result = SCardListReaders(context_, nullptr, nullptr, &readersLen);
+
+    if (result == SCARD_E_NO_READERS_AVAILABLE) {
+        // No readers - return empty array
+        return Napi::Array::New(env, 0);
+    }
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Allocate buffer and get reader names
+    std::vector<char> readersBuffer(readersLen);
+    result = SCardListReaders(context_, nullptr, readersBuffer.data(), &readersLen);
+
+    if (result != SCARD_S_SUCCESS) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Parse multi-string result (null-separated, double-null terminated)
+    std::vector<std::string> readerNames;
+    const char* p = readersBuffer.data();
+    while (*p != '\0') {
+        readerNames.push_back(std::string(p));
+        p += strlen(p) + 1;
+    }
+
+    // Get initial state for each reader
+    std::vector<SCARD_READERSTATE> states(readerNames.size());
+    for (size_t i = 0; i < readerNames.size(); i++) {
+        states[i].szReader = readerNames[i].c_str();
+        states[i].dwCurrentState = SCARD_STATE_UNAWARE;
+    }
+
+    // Get current state (non-blocking with 0 timeout)
+    result = SCardGetStatusChange(context_, 0, states.data(), states.size());
+
+    // Create Reader objects
+    Napi::Array readers = Napi::Array::New(env, readerNames.size());
+    for (size_t i = 0; i < readerNames.size(); i++) {
+        std::vector<uint8_t> atr;
+        if (result == SCARD_S_SUCCESS && states[i].cbAtr > 0) {
+            atr.assign(states[i].rgbAtr, states[i].rgbAtr + states[i].cbAtr);
+        }
+        DWORD state = (result == SCARD_S_SUCCESS) ? states[i].dwEventState : 0;
+
+        Napi::Object reader = PCSCReader::NewInstance(env, context_, readerNames[i], state, atr);
+        readers.Set(static_cast<uint32_t>(i), reader);
+    }
+
+    return readers;
+}
+
+Napi::Value PCSCContext::WaitForChange(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        Napi::Error::New(env, "Context is not valid").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Parse arguments: readers array (optional), timeout (optional)
+    std::vector<std::string> readerNames;
+    std::vector<DWORD> currentStates;
+    DWORD timeout = INFINITE;
+
+    size_t argIndex = 0;
+
+    // First argument can be array of readers or timeout
+    if (info.Length() > 0 && info[0].IsArray()) {
+        Napi::Array readersArray = info[0].As<Napi::Array>();
+        for (uint32_t i = 0; i < readersArray.Length(); i++) {
+            Napi::Value item = readersArray.Get(i);
+            if (item.IsObject()) {
+                // It's a Reader object
+                Napi::Object obj = item.As<Napi::Object>();
+                if (obj.Has("name")) {
+                    readerNames.push_back(obj.Get("name").As<Napi::String>().Utf8Value());
+                    if (obj.Has("state")) {
+                        currentStates.push_back(obj.Get("state").As<Napi::Number>().Uint32Value());
+                    } else {
+                        currentStates.push_back(SCARD_STATE_UNAWARE);
+                    }
+                }
+            } else if (item.IsString()) {
+                readerNames.push_back(item.As<Napi::String>().Utf8Value());
+                currentStates.push_back(SCARD_STATE_UNAWARE);
+            }
+        }
+        argIndex++;
+    }
+
+    // Next argument is timeout
+    if (info.Length() > argIndex && info[argIndex].IsNumber()) {
+        timeout = info[argIndex].As<Napi::Number>().Uint32Value();
+    }
+
+    // If no readers specified, get all readers
+    if (readerNames.empty()) {
+        DWORD readersLen = 0;
+        LONG result = SCardListReaders(context_, nullptr, nullptr, &readersLen);
+
+        if (result == SCARD_E_NO_READERS_AVAILABLE) {
+            // Add PnP notification to detect when readers are attached
+            readerNames.push_back("\\\\?PnP?\\Notification");
+            currentStates.push_back(SCARD_STATE_UNAWARE);
+        } else if (result == SCARD_S_SUCCESS) {
+            std::vector<char> readersBuffer(readersLen);
+            result = SCardListReaders(context_, nullptr, readersBuffer.data(), &readersLen);
+            if (result == SCARD_S_SUCCESS) {
+                const char* p = readersBuffer.data();
+                while (*p != '\0') {
+                    readerNames.push_back(std::string(p));
+                    currentStates.push_back(SCARD_STATE_UNAWARE);
+                    p += strlen(p) + 1;
+                }
+            }
+        }
+    }
+
+    // Create promise and start async worker
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    WaitForChangeWorker* worker = new WaitForChangeWorker(
+        env, context_, readerNames, currentStates, timeout, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}
+
+Napi::Value PCSCContext::Cancel(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (!valid_) {
+        return env.Undefined();
+    }
+
+    LONG result = SCardCancel(context_);
+    if (result != SCARD_S_SUCCESS && result != SCARD_E_INVALID_HANDLE) {
+        Napi::Error::New(env, GetPCSCErrorString(result)).ThrowAsJavaScriptException();
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCContext::Close(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (valid_ && context_ != 0) {
+        SCardReleaseContext(context_);
+        valid_ = false;
+        context_ = 0;
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value PCSCContext::GetIsValid(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), valid_);
+}

package/src/pcsc_context.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <napi.h>
+#include <string>
+#include <vector>
+#include "platform/pcsc.h"
+
+class PCSCContext : public Napi::ObjectWrap<PCSCContext> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Object NewInstance(Napi::Env env);
+
+    PCSCContext(const Napi::CallbackInfo& info);
+    ~PCSCContext();
+
+    // Get the raw context handle (for use by other classes)
+    SCARDCONTEXT GetContext() const { return context_; }
+    bool IsValid() const { return valid_; }
+
+private:
+    static Napi::FunctionReference constructor;
+
+    SCARDCONTEXT context_;
+    bool valid_;
+
+    // JavaScript-exposed methods
+    Napi::Value ListReaders(const Napi::CallbackInfo& info);
+    Napi::Value WaitForChange(const Napi::CallbackInfo& info);
+    Napi::Value Cancel(const Napi::CallbackInfo& info);
+    Napi::Value Close(const Napi::CallbackInfo& info);
+    Napi::Value GetIsValid(const Napi::CallbackInfo& info);
+};

package/src/pcsc_errors.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "platform/pcsc.h"
+
+// Convert PC/SC error codes to human-readable strings
+// Using explicit casts to handle unsigned->signed on macOS
+inline const char* GetPCSCErrorString(LONG code) {
+    // Cast to unsigned for comparison to avoid sign issues
+    DWORD ucode = static_cast<DWORD>(code);
+
+    if (ucode == SCARD_S_SUCCESS) return "Success";
+    if (ucode == SCARD_E_CANCELLED) return "Operation cancelled";
+    if (ucode == SCARD_E_CANT_DISPOSE) return "Cannot dispose handle";
+    if (ucode == SCARD_E_INSUFFICIENT_BUFFER) return "Insufficient buffer";
+    if (ucode == SCARD_E_INVALID_ATR) return "Invalid ATR";
+    if (ucode == SCARD_E_INVALID_HANDLE) return "Invalid handle";
+    if (ucode == SCARD_E_INVALID_PARAMETER) return "Invalid parameter";
+    if (ucode == SCARD_E_INVALID_TARGET) return "Invalid target";
+    if (ucode == SCARD_E_INVALID_VALUE) return "Invalid value";
+    if (ucode == SCARD_E_NO_MEMORY) return "Not enough memory";
+    if (ucode == SCARD_E_NO_SERVICE) return "PC/SC service not running";
+    if (ucode == SCARD_E_NO_SMARTCARD) return "No smart card present";
+    if (ucode == SCARD_E_NOT_READY) return "Reader not ready";
+    if (ucode == SCARD_E_NOT_TRANSACTED) return "Transaction failed";
+    if (ucode == SCARD_E_PCI_TOO_SMALL) return "PCI struct too small";
+    if (ucode == SCARD_E_PROTO_MISMATCH) return "Protocol mismatch";
+    if (ucode == SCARD_E_READER_UNAVAILABLE) return "Reader unavailable";
+    if (ucode == SCARD_E_SERVICE_STOPPED) return "PC/SC service stopped";
+    if (ucode == SCARD_E_SHARING_VIOLATION) return "Sharing violation";
+    if (ucode == SCARD_E_SYSTEM_CANCELLED) return "System cancelled operation";
+    if (ucode == SCARD_E_TIMEOUT) return "Operation timed out";
+    if (ucode == SCARD_E_UNKNOWN_CARD) return "Unknown card type";
+    if (ucode == SCARD_E_UNKNOWN_READER) return "Unknown reader";
+    if (ucode == SCARD_E_NO_READERS_AVAILABLE) return "No readers available";
+    if (ucode == SCARD_F_COMM_ERROR) return "Communication error";
+    if (ucode == SCARD_F_INTERNAL_ERROR) return "Internal error";
+    if (ucode == SCARD_W_REMOVED_CARD) return "Card was removed";
+    if (ucode == SCARD_W_RESET_CARD) return "Card was reset";
+    if (ucode == SCARD_W_UNPOWERED_CARD) return "Card is unpowered";
+    if (ucode == SCARD_W_UNRESPONSIVE_CARD) return "Card is unresponsive";
+    if (ucode == SCARD_W_UNSUPPORTED_CARD) return "Card is not supported";
+
+    return "Unknown PC/SC error";
+}
+
+// Get the error code value
+inline LONG GetPCSCErrorCode(LONG code) {
+    return code;
+}

package/src/pcsc_reader.cpp

@@ -0,0 +1,89 @@
+#include "pcsc_reader.h"
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include "async_workers.h"
+
+Napi::FunctionReference PCSCReader::constructor;
+
+Napi::Object PCSCReader::Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Reader", {
+        InstanceAccessor("name", &PCSCReader::GetNameValue, nullptr),
+        InstanceAccessor("state", &PCSCReader::GetStateValue, nullptr),
+        InstanceAccessor("atr", &PCSCReader::GetAtrValue, nullptr),
+        InstanceMethod("connect", &PCSCReader::Connect),
+    });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("Reader", func);
+    return exports;
+}
+
+Napi::Object PCSCReader::NewInstance(Napi::Env env, SCARDCONTEXT context,
+                                      const std::string& name, DWORD state,
+                                      const std::vector<uint8_t>& atr) {
+    Napi::Object obj = constructor.New({});
+    PCSCReader* reader = Napi::ObjectWrap<PCSCReader>::Unwrap(obj);
+    reader->context_ = context;
+    reader->name_ = name;
+    reader->state_ = state;
+    reader->atr_ = atr;
+    return obj;
+}
+
+PCSCReader::PCSCReader(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<PCSCReader>(info),
+      context_(0),
+      state_(SCARD_STATE_UNAWARE) {
+    // Properties set via NewInstance
+}
+
+void PCSCReader::UpdateState(DWORD state, const std::vector<uint8_t>& atr) {
+    state_ = state;
+    atr_ = atr;
+}
+
+Napi::Value PCSCReader::GetNameValue(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), name_);
+}
+
+Napi::Value PCSCReader::GetStateValue(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), state_);
+}
+
+Napi::Value PCSCReader::GetAtrValue(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (atr_.empty()) {
+        return env.Null();
+    }
+
+    Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(env, atr_.data(), atr_.size());
+    return buffer;
+}
+
+Napi::Value PCSCReader::Connect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    // Parse arguments: shareMode (optional), preferredProtocols (optional)
+    DWORD shareMode = SCARD_SHARE_SHARED;
+    DWORD preferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
+
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        shareMode = info[0].As<Napi::Number>().Uint32Value();
+    }
+
+    if (info.Length() > 1 && info[1].IsNumber()) {
+        preferredProtocols = info[1].As<Napi::Number>().Uint32Value();
+    }
+
+    // Create promise for async connection
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    ConnectWorker* worker = new ConnectWorker(
+        env, context_, name_, shareMode, preferredProtocols, deferred);
+    worker->Queue();
+
+    return deferred.Promise();
+}