smartcard 1.0.46 → 2.0.0

package/lib/errors.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Base error class for PC/SC errors
+ */
+class PCSCError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'PCSCError';
+        this.code = code;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+/**
+ * Error thrown when a card is removed during an operation
+ */
+class CardRemovedError extends PCSCError {
+    constructor(message = 'Card was removed') {
+        super(message, 0x80100069);
+        this.name = 'CardRemovedError';
+    }
+}
+
+/**
+ * Error thrown when an operation times out
+ */
+class TimeoutError extends PCSCError {
+    constructor(message = 'Operation timed out') {
+        super(message, 0x8010000A);
+        this.name = 'TimeoutError';
+    }
+}
+
+/**
+ * Error thrown when no readers are available
+ */
+class NoReadersError extends PCSCError {
+    constructor(message = 'No readers available') {
+        super(message, 0x8010002E);
+        this.name = 'NoReadersError';
+    }
+}
+
+/**
+ * Error thrown when PC/SC service is not running
+ */
+class ServiceNotRunningError extends PCSCError {
+    constructor(message = 'PC/SC service not running') {
+        super(message, 0x8010001D);
+        this.name = 'ServiceNotRunningError';
+    }
+}
+
+/**
+ * Error thrown when there's a sharing violation
+ */
+class SharingViolationError extends PCSCError {
+    constructor(message = 'Sharing violation - card is in use') {
+        super(message, 0x8010000B);
+        this.name = 'SharingViolationError';
+    }
+}
+
+module.exports = {
+    PCSCError,
+    CardRemovedError,
+    TimeoutError,
+    NoReadersError,
+    ServiceNotRunningError,
+    SharingViolationError,
+};

package/lib/index.d.ts

@@ -0,0 +1,247 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+
+/**
+ * Reader state information returned from waitForChange
+ */
+export interface ReaderState {
+    name: string;
+    state: number;
+    changed: boolean;
+    atr: Buffer | null;
+}
+
+/**
+ * Card status information
+ */
+export interface CardStatus {
+    state: number;
+    protocol: number;
+    atr: Buffer;
+}
+
+/**
+ * Represents a connected smart card
+ */
+export interface Card {
+    /** The active protocol (T0, T1, or RAW) */
+    readonly protocol: number;
+    /** Whether the card is still connected */
+    readonly connected: boolean;
+    /** The card's ATR (Answer To Reset) */
+    readonly atr: Buffer | null;
+
+    /**
+     * Transmit an APDU command to the card
+     * @param command - The command buffer or byte array
+     * @returns Promise resolving to the response buffer
+     */
+    transmit(command: Buffer | number[]): Promise<Buffer>;
+
+    /**
+     * Send a control command to the reader
+     * @param code - Control code
+     * @param data - Optional data buffer
+     * @returns Promise resolving to the response buffer
+     */
+    control(code: number, data?: Buffer | number[]): Promise<Buffer>;
+
+    /**
+     * Get the current card status
+     * @returns Card status object
+     */
+    getStatus(): CardStatus;
+
+    /**
+     * Disconnect from the card
+     * @param disposition - What to do with the card (default: SCARD_LEAVE_CARD)
+     */
+    disconnect(disposition?: number): void;
+
+    /**
+     * Reconnect to the card
+     * @param shareMode - Share mode
+     * @param protocol - Preferred protocol(s)
+     * @param initialization - Initialization action
+     * @returns The new active protocol
+     */
+    reconnect(shareMode?: number, protocol?: number, initialization?: number): number;
+}
+
+/**
+ * Represents a smart card reader
+ */
+export interface Reader {
+    /** The reader name */
+    readonly name: string;
+    /** Current reader state flags */
+    readonly state: number;
+    /** ATR of the card if present */
+    readonly atr: Buffer | null;
+
+    /**
+     * Connect to a card in the reader
+     * @param shareMode - Share mode (default: SCARD_SHARE_SHARED)
+     * @param protocol - Preferred protocol(s) (default: T0 | T1)
+     * @returns Promise resolving to a Card object
+     */
+    connect(shareMode?: number, protocol?: number): Promise<Card>;
+}
+
+/**
+ * Low-level PC/SC context
+ */
+export declare class Context {
+    constructor();
+
+    /** Whether the context is still valid */
+    readonly isValid: boolean;
+
+    /**
+     * List available readers
+     * @returns Array of Reader objects
+     */
+    listReaders(): Reader[];
+
+    /**
+     * Wait for reader/card state changes
+     * @param readers - Optional array of readers to monitor
+     * @param timeout - Timeout in milliseconds (default: infinite)
+     * @returns Promise resolving to array of reader states
+     */
+    waitForChange(readers?: Reader[] | ReaderState[], timeout?: number): Promise<ReaderState[] | null>;
+
+    /**
+     * Cancel a pending waitForChange call
+     */
+    cancel(): void;
+
+    /**
+     * Close the context and release resources
+     */
+    close(): void;
+}
+
+/**
+ * Monitor event from native ReaderMonitor
+ */
+export interface MonitorEvent {
+    type: 'reader-attached' | 'reader-detached' | 'card-inserted' | 'card-removed' | 'error';
+    reader: string;
+    state: number;
+    atr: Buffer | null;
+}
+
+/**
+ * Native PC/SC event monitor using ThreadSafeFunction
+ * Runs monitoring on a background thread for efficiency
+ */
+export declare class ReaderMonitor {
+    constructor();
+
+    /** Whether the monitor is currently running */
+    readonly isRunning: boolean;
+
+    /**
+     * Start monitoring for reader/card changes
+     * @param callback - Function called when events occur
+     */
+    start(callback: (event: MonitorEvent) => void): void;
+
+    /**
+     * Stop monitoring
+     */
+    stop(): void;
+}
+
+/**
+ * Event types for Devices class
+ */
+export interface DeviceEvents {
+    'reader-attached': (reader: Reader) => void;
+    'reader-detached': (reader: Reader) => void;
+    'card-inserted': (event: { reader: Reader; card: Card }) => void;
+    'card-removed': (event: { reader: Reader; card: Card | null }) => void;
+    'error': (error: Error) => void;
+}
+
+/**
+ * High-level event-driven API for monitoring PC/SC devices
+ */
+export declare class Devices extends EventEmitter {
+    constructor();
+
+    /**
+     * Start monitoring for device changes
+     */
+    start(): void;
+
+    /**
+     * Stop monitoring and release resources
+     */
+    stop(): void;
+
+    /**
+     * List currently known readers
+     * @returns Array of Reader objects
+     */
+    listReaders(): Reader[];
+
+    on<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
+    once<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
+    off<K extends keyof DeviceEvents>(event: K, listener: DeviceEvents[K]): this;
+    emit<K extends keyof DeviceEvents>(event: K, ...args: Parameters<DeviceEvents[K]>): boolean;
+}
+
+/**
+ * Base PC/SC error class
+ */
+export declare class PCSCError extends Error {
+    readonly code: number;
+    constructor(message: string, code: number);
+}
+
+/**
+ * Error thrown when card is removed during operation
+ */
+export declare class CardRemovedError extends PCSCError {
+    constructor(message?: string);
+}
+
+/**
+ * Error thrown when operation times out
+ */
+export declare class TimeoutError extends PCSCError {
+    constructor(message?: string);
+}
+
+// Share modes
+export declare const SCARD_SHARE_EXCLUSIVE: number;
+export declare const SCARD_SHARE_SHARED: number;
+export declare const SCARD_SHARE_DIRECT: number;
+
+// Protocols
+export declare const SCARD_PROTOCOL_T0: number;
+export declare const SCARD_PROTOCOL_T1: number;
+export declare const SCARD_PROTOCOL_RAW: number;
+export declare const SCARD_PROTOCOL_UNDEFINED: number;
+
+// Disposition
+export declare const SCARD_LEAVE_CARD: number;
+export declare const SCARD_RESET_CARD: number;
+export declare const SCARD_UNPOWER_CARD: number;
+export declare const SCARD_EJECT_CARD: number;
+
+// State flags
+export declare const SCARD_STATE_UNAWARE: number;
+export declare const SCARD_STATE_IGNORE: number;
+export declare const SCARD_STATE_CHANGED: number;
+export declare const SCARD_STATE_UNKNOWN: number;
+export declare const SCARD_STATE_UNAVAILABLE: number;
+export declare const SCARD_STATE_EMPTY: number;
+export declare const SCARD_STATE_PRESENT: number;
+export declare const SCARD_STATE_ATRMATCH: number;
+export declare const SCARD_STATE_EXCLUSIVE: number;
+export declare const SCARD_STATE_INUSE: number;
+export declare const SCARD_STATE_MUTE: number;

package/lib/index.js

@@ -1,24 +1,86 @@
 'use strict';
 
-var _Iso7816Application = _interopRequireDefault(require("./Iso7816Application"));
+const path = require('path');
 
-var _CommandApdu = _interopRequireDefault(require("./CommandApdu"));
+// Load native addon
+const addon = require('../build/Release/smartcard_napi.node');
 
-var _ResponseApdu = _interopRequireDefault(require("./ResponseApdu"));
+// Re-export native classes
+const { Context, Reader, Card, ReaderMonitor } = addon;
 
-var _Devices = _interopRequireDefault(require("./Devices"));
+// Re-export constants
+const SCARD_SHARE_EXCLUSIVE = addon.SCARD_SHARE_EXCLUSIVE;
+const SCARD_SHARE_SHARED = addon.SCARD_SHARE_SHARED;
+const SCARD_SHARE_DIRECT = addon.SCARD_SHARE_DIRECT;
 
-var _Device = _interopRequireDefault(require("./Device"));
+const SCARD_PROTOCOL_T0 = addon.SCARD_PROTOCOL_T0;
+const SCARD_PROTOCOL_T1 = addon.SCARD_PROTOCOL_T1;
+const SCARD_PROTOCOL_RAW = addon.SCARD_PROTOCOL_RAW;
+const SCARD_PROTOCOL_UNDEFINED = addon.SCARD_PROTOCOL_UNDEFINED;
 
-var _Card = _interopRequireDefault(require("./Card"));
+const SCARD_LEAVE_CARD = addon.SCARD_LEAVE_CARD;
+const SCARD_RESET_CARD = addon.SCARD_RESET_CARD;
+const SCARD_UNPOWER_CARD = addon.SCARD_UNPOWER_CARD;
+const SCARD_EJECT_CARD = addon.SCARD_EJECT_CARD;
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+const SCARD_STATE_UNAWARE = addon.SCARD_STATE_UNAWARE;
+const SCARD_STATE_IGNORE = addon.SCARD_STATE_IGNORE;
+const SCARD_STATE_CHANGED = addon.SCARD_STATE_CHANGED;
+const SCARD_STATE_UNKNOWN = addon.SCARD_STATE_UNKNOWN;
+const SCARD_STATE_UNAVAILABLE = addon.SCARD_STATE_UNAVAILABLE;
+const SCARD_STATE_EMPTY = addon.SCARD_STATE_EMPTY;
+const SCARD_STATE_PRESENT = addon.SCARD_STATE_PRESENT;
+const SCARD_STATE_ATRMATCH = addon.SCARD_STATE_ATRMATCH;
+const SCARD_STATE_EXCLUSIVE = addon.SCARD_STATE_EXCLUSIVE;
+const SCARD_STATE_INUSE = addon.SCARD_STATE_INUSE;
+const SCARD_STATE_MUTE = addon.SCARD_STATE_MUTE;
+
+// Import Devices class
+const { Devices } = require('./devices');
+
+// Import error classes
+const { PCSCError, CardRemovedError, TimeoutError } = require('./errors');
 
 module.exports = {
-  Iso7816Application: _Iso7816Application["default"],
-  CommandApdu: _CommandApdu["default"],
-  ResponseApdu: _ResponseApdu["default"],
-  Devices: _Devices["default"],
-  Device: _Device["default"],
-  Card: _Card["default"]
-};
+    // Classes
+    Context,
+    Reader,
+    Card,
+    Devices,
+    ReaderMonitor,
+
+    // Error classes
+    PCSCError,
+    CardRemovedError,
+    TimeoutError,
+
+    // Share modes
+    SCARD_SHARE_EXCLUSIVE,
+    SCARD_SHARE_SHARED,
+    SCARD_SHARE_DIRECT,
+
+    // Protocols
+    SCARD_PROTOCOL_T0,
+    SCARD_PROTOCOL_T1,
+    SCARD_PROTOCOL_RAW,
+    SCARD_PROTOCOL_UNDEFINED,
+
+    // Disposition
+    SCARD_LEAVE_CARD,
+    SCARD_RESET_CARD,
+    SCARD_UNPOWER_CARD,
+    SCARD_EJECT_CARD,
+
+    // State flags
+    SCARD_STATE_UNAWARE,
+    SCARD_STATE_IGNORE,
+    SCARD_STATE_CHANGED,
+    SCARD_STATE_UNKNOWN,
+    SCARD_STATE_UNAVAILABLE,
+    SCARD_STATE_EMPTY,
+    SCARD_STATE_PRESENT,
+    SCARD_STATE_ATRMATCH,
+    SCARD_STATE_EXCLUSIVE,
+    SCARD_STATE_INUSE,
+    SCARD_STATE_MUTE,
+};

package/package.json

@@ -1,41 +1,58 @@
 {
-  "name": "smartcard",
-  "version": "1.0.46",
-  "author": "tomkp <tom@tomkp.com>",
-  "keywords": [
-    "pcsc",
-    "smartcard",
-    "smart-card",
-    "iso7816",
-    "iso-7816",
-    "emv",
-    "es6"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tomkp/smartcard.git"
-  },
-  "bugs": {
-    "url": "https://github.com/tomkp/smartcard/issues"
-  },
-  "homepage": "https://github.com/tomkp/smartcard",
-  "main": "lib/index.js",
-  "scripts": {
-    "compile": "babel -d lib/ src/",
-    "compile:watch": "babel -w -d lib/ src/",
-    "release:patch": "npm run compile && npm version patch && git push && yarn publish",
-    "prettier": "prettier --write \"{src,demo}/**/*.{js,ts}\""
-  },
-  "dependencies": {
-    "@pokusew/pcsclite": "^0.6.0",
-    "hexify": "^1.0.4",
-    "pino": "^6.11.1"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.12.16",
-    "@babel/core": "^7.12.16",
-    "@babel/preset-env": "^7.12.16",
-    "prettier": "^2.2.1"
-  }
+    "name": "smartcard",
+    "version": "2.0.0",
+    "description": "PC/SC bindings for Node.js using N-API - ABI stable across Node.js versions",
+    "author": "Tom KP",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tomkp/smartcard.git"
+    },
+    "bugs": {
+        "url": "https://github.com/tomkp/smartcard/issues"
+    },
+    "homepage": "https://github.com/tomkp/smartcard#readme",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "gypfile": true,
+    "scripts": {
+        "install": "node-gyp rebuild",
+        "build": "node-gyp rebuild",
+        "rebuild": "node-gyp rebuild",
+        "test": "node test/test.js"
+    },
+    "files": [
+        "lib/",
+        "src/",
+        "binding.gyp",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "node-addon-api": "^7.0.0"
+    },
+    "devDependencies": {
+        "node-gyp": "^10.0.0"
+    },
+    "engines": {
+        "node": ">=12.0.0"
+    },
+    "os": [
+        "darwin",
+        "linux",
+        "win32"
+    ],
+    "keywords": [
+        "pcsc",
+        "pcsclite",
+        "smartcard",
+        "smart-card",
+        "nfc",
+        "rfid",
+        "contactless",
+        "napi",
+        "node-addon-api",
+        "acr122",
+        "card-reader"
+    ]
 }

package/src/addon.cpp

@@ -0,0 +1,54 @@
+#include <napi.h>
+#include "pcsc_context.h"
+#include "pcsc_reader.h"
+#include "pcsc_card.h"
+#include "reader_monitor.h"
+#include "platform/pcsc.h"
+
+// Export PC/SC constants
+void ExportConstants(Napi::Env env, Napi::Object exports) {
+    // Share modes
+    exports.Set("SCARD_SHARE_EXCLUSIVE", Napi::Number::New(env, SCARD_SHARE_EXCLUSIVE));
+    exports.Set("SCARD_SHARE_SHARED", Napi::Number::New(env, SCARD_SHARE_SHARED));
+    exports.Set("SCARD_SHARE_DIRECT", Napi::Number::New(env, SCARD_SHARE_DIRECT));
+
+    // Protocols
+    exports.Set("SCARD_PROTOCOL_T0", Napi::Number::New(env, SCARD_PROTOCOL_T0));
+    exports.Set("SCARD_PROTOCOL_T1", Napi::Number::New(env, SCARD_PROTOCOL_T1));
+    exports.Set("SCARD_PROTOCOL_RAW", Napi::Number::New(env, SCARD_PROTOCOL_RAW));
+    exports.Set("SCARD_PROTOCOL_UNDEFINED", Napi::Number::New(env, SCARD_PROTOCOL_UNDEFINED));
+
+    // Disposition
+    exports.Set("SCARD_LEAVE_CARD", Napi::Number::New(env, SCARD_LEAVE_CARD));
+    exports.Set("SCARD_RESET_CARD", Napi::Number::New(env, SCARD_RESET_CARD));
+    exports.Set("SCARD_UNPOWER_CARD", Napi::Number::New(env, SCARD_UNPOWER_CARD));
+    exports.Set("SCARD_EJECT_CARD", Napi::Number::New(env, SCARD_EJECT_CARD));
+
+    // State flags
+    exports.Set("SCARD_STATE_UNAWARE", Napi::Number::New(env, SCARD_STATE_UNAWARE));
+    exports.Set("SCARD_STATE_IGNORE", Napi::Number::New(env, SCARD_STATE_IGNORE));
+    exports.Set("SCARD_STATE_CHANGED", Napi::Number::New(env, SCARD_STATE_CHANGED));
+    exports.Set("SCARD_STATE_UNKNOWN", Napi::Number::New(env, SCARD_STATE_UNKNOWN));
+    exports.Set("SCARD_STATE_UNAVAILABLE", Napi::Number::New(env, SCARD_STATE_UNAVAILABLE));
+    exports.Set("SCARD_STATE_EMPTY", Napi::Number::New(env, SCARD_STATE_EMPTY));
+    exports.Set("SCARD_STATE_PRESENT", Napi::Number::New(env, SCARD_STATE_PRESENT));
+    exports.Set("SCARD_STATE_ATRMATCH", Napi::Number::New(env, SCARD_STATE_ATRMATCH));
+    exports.Set("SCARD_STATE_EXCLUSIVE", Napi::Number::New(env, SCARD_STATE_EXCLUSIVE));
+    exports.Set("SCARD_STATE_INUSE", Napi::Number::New(env, SCARD_STATE_INUSE));
+    exports.Set("SCARD_STATE_MUTE", Napi::Number::New(env, SCARD_STATE_MUTE));
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    // Initialize wrapper classes
+    PCSCContext::Init(env, exports);
+    PCSCReader::Init(env, exports);
+    PCSCCard::Init(env, exports);
+    ReaderMonitor::Init(env, exports);
+
+    // Export constants
+    ExportConstants(env, exports);
+
+    return exports;
+}
+
+NODE_API_MODULE(smartcard_napi, Init)