intgate 1.0.0

package/README.md

@@ -0,0 +1,325 @@
+# IntGate Node.js/TypeScript Client Library
+
+Node.js and TypeScript client library for the [IntGate](https://license.intserver.com) license verification API.
+
+## Installation
+
+```bash
+npm install intgate
+```
+
+Or with yarn:
+
+```bash
+yarn add intgate
+```
+
+## Quick Start
+
+### TypeScript
+
+```typescript
+import { IntGateClient } from 'intgate';
+
+// Initialize the client with your team ID
+const client = new IntGateClient('your-team-uuid-here');
+
+// Verify a license
+async function verifyLicense() {
+  try {
+    const result = await client.verifyLicense({
+      licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+      hardwareIdentifier: 'unique-device-id',
+      version: '1.0.0'
+    });
+    
+    if (result.result.valid) {
+      console.log('License is valid!');
+      console.log('License data:', result.data);
+    } else {
+      console.log('License invalid:', result.result.details);
+    }
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+verifyLicense();
+```
+
+### JavaScript
+
+```javascript
+const { IntGateClient } = require('intgate');
+
+// Initialize the client with your team ID
+const client = new IntGateClient('your-team-uuid-here');
+
+// Verify a license
+async function verifyLicense() {
+  try {
+    const result = await client.verifyLicense({
+      licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+      hardwareIdentifier: 'unique-device-id',
+      version: '1.0.0'
+    });
+    
+    if (result.result.valid) {
+      console.log('License is valid!');
+    }
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+```
+
+## API Reference
+
+### Initialize Client
+
+```typescript
+import { IntGateClient } from 'intgate';
+
+const client = new IntGateClient(
+  'your-team-uuid',  // Required: Your team's UUID from IntGate dashboard
+  'https://license.intserver.com/api/v1'  // Optional: Custom API base URL
+);
+```
+
+### Verify License
+
+Validates a license key and returns license information, customer data, and product details.
+
+```typescript
+const result = await client.verifyLicense({
+  licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',  // Required
+  customerId: 'customer-uuid',  // Optional: Required if strict customers enabled
+  productId: 'product-uuid',  // Optional: Required if strict products enabled
+  challenge: 'random-string',  // Optional: For request signing
+  version: '1.0.0',  // Optional: Software version (3-255 chars)
+  hardwareIdentifier: 'device-id',  // Optional: Unique device ID (10-1000 chars)
+  branch: 'main'  // Optional: Product branch (2-255 chars)
+});
+```
+
+### License Heartbeat
+
+Send periodic heartbeats to determine if a device is still active.
+
+```typescript
+const result = await client.licenseHeartbeat({
+  licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',  // Required
+  hardwareIdentifier: 'device-id',  // Required: Unique device ID (10-1000 chars)
+  customerId: 'customer-uuid',  // Optional
+  productId: 'product-uuid',  // Optional
+  challenge: 'random-string',  // Optional
+  version: '1.0.0',  // Optional: Software version (3-255 chars)
+  branch: 'main'  // Optional: Product branch (2-255 chars)
+});
+```
+
+### Download Release
+
+Download an encrypted release file.
+
+```typescript
+const encryptedFile = await client.downloadRelease({
+  licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',  // Required
+  productId: 'product-uuid',  // Required
+  sessionKey: 'encrypted-session-key',  // Required: Encrypted with team's public key
+  hardwareIdentifier: 'device-id',  // Required: Unique device ID
+  version: '1.0.0',  // Required: Software version
+  customerId: 'customer-uuid',  // Optional
+  branch: 'main'  // Optional: Product branch
+});
+
+// Save to file:
+import fs from 'fs';
+fs.writeFileSync('release.encrypted', encryptedFile);
+```
+
+## Automatic Heartbeat
+
+Start automatic heartbeat in the background with event-based notifications.
+
+```typescript
+import { IntGateClient } from 'intgate';
+
+const client = new IntGateClient('your-team-uuid');
+
+// Listen for heartbeat events
+client.on('heartbeat', (result) => {
+    console.log(`✓ Heartbeat OK at ${result.result.timestamp}`);
+    console.log(`  License valid: ${result.result.valid}`);
+});
+
+client.on('heartbeat-error', (error) => {
+    console.error('✗ Heartbeat failed:', error);
+});
+
+// Start automatic heartbeat (runs with setTimeout)
+client.startAutomaticHeartbeat(
+    {
+        licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+        hardwareIdentifier: 'device-12345',
+        version: '1.0.0'
+    },
+    1800000  // 30 minutes in milliseconds
+);
+
+console.log('Application running with automatic heartbeat...');
+
+// Get last heartbeat result anytime
+const lastResult = client.getLastHeartbeatResult();
+if (lastResult?.result.valid) {
+    console.log('License is active');
+}
+
+// Check if heartbeat is running
+if (client.isHeartbeatRunning()) {
+    console.log('Automatic heartbeat is active');
+}
+
+// Stop when done
+client.stopAutomaticHeartbeat();
+```
+
+## Error Handling
+
+The library provides specific exception types:
+
+```typescript
+import { 
+  IntGateClient, 
+  IntGateAPIError, 
+  IntGateValidationError 
+} from 'intgate';
+
+const client = new IntGateClient('your-team-uuid');
+
+try {
+  const result = await client.verifyLicense({
+    licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'
+  });
+} catch (error) {
+  if (error instanceof IntGateValidationError) {
+    // Input validation failed
+    console.error('Validation error:', error.message);
+  } else if (error instanceof IntGateAPIError) {
+    // API request failed
+    console.error('API error:', error.message);
+    console.error('Status code:', error.statusCode);
+    console.error('Response data:', error.responseData);
+  } else {
+    // Other errors
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+## Complete Example
+
+```typescript
+import { IntGateClient, IntGateAPIError } from 'intgate';
+
+// Initialize client
+const client = new IntGateClient('your-team-uuid-here');
+
+async function main() {
+  try {
+    // Verify license on startup
+    console.log('Verifying license...');
+    const result = await client.verifyLicense({
+      licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+      hardwareIdentifier: 'my-device-12345',
+      version: '1.0.0',
+      productId: 'your-product-uuid'
+    });
+    
+    if (!result.result.valid) {
+      console.error('License validation failed:', result.result.details);
+      process.exit(1);
+    }
+    
+    console.log('License verified successfully!');
+    console.log('Expires:', result.data.license.expirationDate || 'Never');
+    
+    // Setup automatic heartbeat with event listeners
+    console.log('\nStarting automatic heartbeat...');
+    
+    client.on('heartbeat', (result) => {
+      console.log('Heartbeat successful');
+    });
+    
+    client.on('heartbeat-error', (error) => {
+      console.error('Heartbeat failed:', error);
+    });
+    
+    client.startAutomaticHeartbeat(
+      {
+        licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+        hardwareIdentifier: 'my-device-12345',
+        version: '1.0.0'
+      },
+      1800000  // Every 30 minutes
+    );
+    
+    console.log('Application running...');
+    
+  } catch (error) {
+    if (error instanceof IntGateAPIError) {
+      console.error('API Error:', error.message);
+      if (error.statusCode === 404) {
+        console.error('License not found');
+      } else if (error.statusCode === 401) {
+        console.error('Unauthorized - check your team ID');
+      }
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+main();
+```
+
+## TypeScript Support
+
+This library is written in TypeScript and includes full type definitions:
+
+```typescript
+import { 
+  IntGateClient,
+  VerifyLicenseOptions,
+  VerifyLicenseResponse,
+  LicenseHeartbeatOptions,
+  HeartbeatResponse,
+  DownloadReleaseOptions,
+  License,
+  Customer,
+  Product,
+  VerificationResult
+} from 'intgate';
+```
+
+## Build from Source
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript to JavaScript
+npm run build
+
+# The built files will be in the dist/ directory
+```
+
+## License
+
+MIT License
+
+## Support
+
+For API documentation, visit: https://license.intserver.com
+
+For examples, see: [AUTOMATIC_HEARTBEAT.md](../AUTOMATIC_HEARTBEAT.md)

package/dist/client.d.ts

@@ -0,0 +1,103 @@
+/**
+ * IntGate API Client implementation for Node.js/TypeScript.
+ */
+import { EventEmitter } from 'events';
+import { VerifyLicenseOptions, LicenseHeartbeatOptions, DownloadReleaseOptions, VerifyLicenseResponse, HeartbeatResponse } from './types';
+/**
+ * Client for interacting with the IntGate license verification API.
+ */
+export declare class IntGateClient extends EventEmitter {
+    private teamId;
+    private baseUrl;
+    private axiosInstance;
+    private heartbeatTimer;
+    private heartbeatRunning;
+    private lastHeartbeatResult;
+    /**
+     * Initialize the IntGate client.
+     * @param teamId Your team's UUID from the IntGate dashboard.
+     * @param baseUrl The base URL for the IntGate API (default: https://license.intserver.com/api/v1).
+     */
+    constructor(teamId: string, baseUrl?: string);
+    /**
+     * Verify a license key with the IntGate backend.
+     *
+     * This endpoint validates a license key and returns license information,
+     * customer data, and product details. Typically called when software starts.
+     *
+     * @param options License verification options
+     * @returns Promise resolving to verification response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    verifyLicense(options: VerifyLicenseOptions): Promise<VerifyLicenseResponse>;
+    /**
+     * Send a heartbeat to determine if a device is still active.
+     *
+     * This endpoint should be called at regular intervals (e.g., every 30 minutes).
+     * It validates the license key similar to verifyLicense.
+     *
+     * @param options Heartbeat options
+     * @returns Promise resolving to heartbeat response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    licenseHeartbeat(options: LicenseHeartbeatOptions): Promise<HeartbeatResponse>;
+    /**
+     * Download an encrypted release file.
+     *
+     * This endpoint is primarily for languages that support loading code remotely
+     * (e.g., Java classloaders). The file is encrypted using the provided session key.
+     *
+     * @param options Download release options
+     * @returns Promise resolving to encrypted file content (Buffer)
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    downloadRelease(options: DownloadReleaseOptions): Promise<Buffer>;
+    /**
+     * Start automatic heartbeat in the background.
+     *
+     * The client will emit 'heartbeat' events with the result on success,
+     * and 'heartbeat-error' events on errors.
+     *
+     * @param options Heartbeat options
+     * @param interval Interval in milliseconds between heartbeats (default: 1800000 = 30 minutes)
+     *
+     * @example
+     * client.startAutomaticHeartbeat({
+     *   licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+     *   hardwareIdentifier: 'device-123'
+     * }, 60000); // Every 1 minute
+     *
+     * client.on('heartbeat', (result) => {
+     *   console.log('Heartbeat successful:', result);
+     * });
+     *
+     * client.on('heartbeat-error', (error) => {
+     *   console.error('Heartbeat failed:', error);
+     * });
+     */
+    startAutomaticHeartbeat(options: LicenseHeartbeatOptions, interval?: number): void;
+    /**
+     * Stop the automatic heartbeat.
+     */
+    stopAutomaticHeartbeat(): void;
+    /**
+     * Get the result of the last automatic heartbeat.
+     *
+     * @returns The last heartbeat result, or null if no heartbeat has run yet
+     */
+    getLastHeartbeatResult(): HeartbeatResponse | null;
+    /**
+     * Check if automatic heartbeat is currently running.
+     *
+     * @returns True if heartbeat is running, false otherwise
+     */
+    isHeartbeatRunning(): boolean;
+    /**
+     * Handle errors from API requests.
+     * @private
+     */
+    private handleError;
+}

package/dist/client.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * IntGate API Client implementation for Node.js/TypeScript.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntGateClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const events_1 = require("events");
+const exceptions_1 = require("./exceptions");
+/**
+ * Client for interacting with the IntGate license verification API.
+ */
+class IntGateClient extends events_1.EventEmitter {
+    /**
+     * Initialize the IntGate client.
+     * @param teamId Your team's UUID from the IntGate dashboard.
+     * @param baseUrl The base URL for the IntGate API (default: https://license.intserver.com/api/v1).
+     */
+    constructor(teamId, baseUrl = 'https://license.intserver.com/api/v1') {
+        super();
+        this.heartbeatTimer = null;
+        this.heartbeatRunning = false;
+        this.lastHeartbeatResult = null;
+        if (!teamId) {
+            throw new exceptions_1.IntGateValidationError('teamId is required');
+        }
+        this.teamId = teamId;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.axiosInstance = axios_1.default.create({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Verify a license key with the IntGate backend.
+     *
+     * This endpoint validates a license key and returns license information,
+     * customer data, and product details. Typically called when software starts.
+     *
+     * @param options License verification options
+     * @returns Promise resolving to verification response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async verifyLicense(options) {
+        if (!options.licenseKey) {
+            throw new exceptions_1.IntGateValidationError('licenseKey is required');
+        }
+        const payload = {
+            licenseKey: options.licenseKey,
+        };
+        if (options.customerId)
+            payload.customerId = options.customerId;
+        if (options.productId)
+            payload.productId = options.productId;
+        if (options.challenge)
+            payload.challenge = options.challenge;
+        if (options.version)
+            payload.version = options.version;
+        if (options.hardwareIdentifier)
+            payload.hardwareIdentifier = options.hardwareIdentifier;
+        if (options.branch)
+            payload.branch = options.branch;
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/verify`;
+        try {
+            const response = await this.axiosInstance.post(url, payload);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Send a heartbeat to determine if a device is still active.
+     *
+     * This endpoint should be called at regular intervals (e.g., every 30 minutes).
+     * It validates the license key similar to verifyLicense.
+     *
+     * @param options Heartbeat options
+     * @returns Promise resolving to heartbeat response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async licenseHeartbeat(options) {
+        if (!options.licenseKey) {
+            throw new exceptions_1.IntGateValidationError('licenseKey is required');
+        }
+        if (!options.hardwareIdentifier) {
+            throw new exceptions_1.IntGateValidationError('hardwareIdentifier is required');
+        }
+        const payload = {
+            licenseKey: options.licenseKey,
+            hardwareIdentifier: options.hardwareIdentifier,
+        };
+        if (options.customerId)
+            payload.customerId = options.customerId;
+        if (options.productId)
+            payload.productId = options.productId;
+        if (options.challenge)
+            payload.challenge = options.challenge;
+        if (options.version)
+            payload.version = options.version;
+        if (options.branch)
+            payload.branch = options.branch;
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/heartbeat`;
+        try {
+            const response = await this.axiosInstance.post(url, payload);
+            return response.data;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Download an encrypted release file.
+     *
+     * This endpoint is primarily for languages that support loading code remotely
+     * (e.g., Java classloaders). The file is encrypted using the provided session key.
+     *
+     * @param options Download release options
+     * @returns Promise resolving to encrypted file content (Buffer)
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async downloadRelease(options) {
+        if (!options.licenseKey) {
+            throw new exceptions_1.IntGateValidationError('licenseKey is required');
+        }
+        if (!options.productId) {
+            throw new exceptions_1.IntGateValidationError('productId is required');
+        }
+        if (!options.sessionKey) {
+            throw new exceptions_1.IntGateValidationError('sessionKey is required');
+        }
+        if (!options.hardwareIdentifier) {
+            throw new exceptions_1.IntGateValidationError('hardwareIdentifier is required');
+        }
+        if (!options.version) {
+            throw new exceptions_1.IntGateValidationError('version is required');
+        }
+        const params = {
+            licenseKey: options.licenseKey,
+            productId: options.productId,
+            sessionKey: options.sessionKey,
+            hardwareIdentifier: options.hardwareIdentifier,
+            version: options.version,
+        };
+        if (options.customerId)
+            params.customerId = options.customerId;
+        if (options.branch)
+            params.branch = options.branch;
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/classloader`;
+        try {
+            const response = await this.axiosInstance.get(url, {
+                params,
+                responseType: 'arraybuffer',
+            });
+            return Buffer.from(response.data);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Start automatic heartbeat in the background.
+     *
+     * The client will emit 'heartbeat' events with the result on success,
+     * and 'heartbeat-error' events on errors.
+     *
+     * @param options Heartbeat options
+     * @param interval Interval in milliseconds between heartbeats (default: 1800000 = 30 minutes)
+     *
+     * @example
+     * client.startAutomaticHeartbeat({
+     *   licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+     *   hardwareIdentifier: 'device-123'
+     * }, 60000); // Every 1 minute
+     *
+     * client.on('heartbeat', (result) => {
+     *   console.log('Heartbeat successful:', result);
+     * });
+     *
+     * client.on('heartbeat-error', (error) => {
+     *   console.error('Heartbeat failed:', error);
+     * });
+     */
+    startAutomaticHeartbeat(options, interval = 1800000) {
+        if (this.heartbeatRunning) {
+            throw new exceptions_1.IntGateValidationError('Automatic heartbeat is already running');
+        }
+        this.heartbeatRunning = true;
+        const runHeartbeat = async () => {
+            try {
+                const result = await this.licenseHeartbeat(options);
+                this.lastHeartbeatResult = result;
+                this.emit('heartbeat', result);
+            }
+            catch (error) {
+                this.emit('heartbeat-error', error);
+            }
+            if (this.heartbeatRunning) {
+                this.heartbeatTimer = setTimeout(runHeartbeat, interval);
+            }
+        };
+        // Run immediately, then schedule
+        runHeartbeat();
+    }
+    /**
+     * Stop the automatic heartbeat.
+     */
+    stopAutomaticHeartbeat() {
+        this.heartbeatRunning = false;
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * Get the result of the last automatic heartbeat.
+     *
+     * @returns The last heartbeat result, or null if no heartbeat has run yet
+     */
+    getLastHeartbeatResult() {
+        return this.lastHeartbeatResult;
+    }
+    /**
+     * Check if automatic heartbeat is currently running.
+     *
+     * @returns True if heartbeat is running, false otherwise
+     */
+    isHeartbeatRunning() {
+        return this.heartbeatRunning;
+    }
+    /**
+     * Handle errors from API requests.
+     * @private
+     */
+    handleError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const axiosError = error;
+            const statusCode = axiosError.response?.status;
+            const responseData = axiosError.response?.data;
+            throw new exceptions_1.IntGateAPIError(`API request failed: ${axiosError.message}`, statusCode, responseData);
+        }
+        throw new exceptions_1.IntGateAPIError(`Network error: ${error.message}`);
+    }
+}
+exports.IntGateClient = IntGateClient;

package/dist/exceptions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Custom error classes for the IntGate API client.
+ */
+/**
+ * Base error class for all IntGate errors.
+ */
+export declare class IntGateError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when the API returns an error response.
+ */
+export declare class IntGateAPIError extends IntGateError {
+    statusCode?: number;
+    responseData?: any;
+    constructor(message: string, statusCode?: number, responseData?: any);
+}
+/**
+ * Error thrown when input validation fails.
+ */
+export declare class IntGateValidationError extends IntGateError {
+    constructor(message: string);
+}

package/dist/exceptions.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Custom error classes for the IntGate API client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntGateValidationError = exports.IntGateAPIError = exports.IntGateError = void 0;
+/**
+ * Base error class for all IntGate errors.
+ */
+class IntGateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IntGateError';
+        Object.setPrototypeOf(this, IntGateError.prototype);
+    }
+}
+exports.IntGateError = IntGateError;
+/**
+ * Error thrown when the API returns an error response.
+ */
+class IntGateAPIError extends IntGateError {
+    constructor(message, statusCode, responseData) {
+        super(message);
+        this.name = 'IntGateAPIError';
+        this.statusCode = statusCode;
+        this.responseData = responseData;
+        Object.setPrototypeOf(this, IntGateAPIError.prototype);
+    }
+}
+exports.IntGateAPIError = IntGateAPIError;
+/**
+ * Error thrown when input validation fails.
+ */
+class IntGateValidationError extends IntGateError {
+    constructor(message) {
+        super(message);
+        this.name = 'IntGateValidationError';
+        Object.setPrototypeOf(this, IntGateValidationError.prototype);
+    }
+}
+exports.IntGateValidationError = IntGateValidationError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * IntGate API Client Library for Node.js/TypeScript
+ * A Node.js/TypeScript client library for the IntGate license verification API.
+ */
+export { IntGateClient } from './client';
+export { IntGateError, IntGateAPIError, IntGateValidationError } from './exceptions';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * IntGate API Client Library for Node.js/TypeScript
+ * A Node.js/TypeScript client library for the IntGate license verification API.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntGateValidationError = exports.IntGateAPIError = exports.IntGateError = exports.IntGateClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "IntGateClient", { enumerable: true, get: function () { return client_1.IntGateClient; } });
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "IntGateError", { enumerable: true, get: function () { return exceptions_1.IntGateError; } });
+Object.defineProperty(exports, "IntGateAPIError", { enumerable: true, get: function () { return exceptions_1.IntGateAPIError; } });
+Object.defineProperty(exports, "IntGateValidationError", { enumerable: true, get: function () { return exceptions_1.IntGateValidationError; } });
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Type definitions for the Lukittu API client.
+ */
+export interface LicenseMetadata {
+    key: string;
+    value: string;
+}
+export interface License {
+    ipLimit: number;
+    hwidLimit: number;
+    expirationType: 'NEVER' | 'DATE' | 'DAYS';
+    expirationStart?: 'CREATION' | 'ACTIVATION';
+    expirationDate?: string;
+    expirationDays?: number;
+    metadata?: LicenseMetadata[];
+}
+export interface Customer {
+    email: string;
+    fullName: string;
+    username: string;
+    metadata?: LicenseMetadata[];
+}
+export interface LatestRelease {
+    version: string;
+    createdAt: string;
+}
+export interface Product {
+    name: string;
+    url: string;
+    latestRelease?: LatestRelease;
+    metadata?: LicenseMetadata[];
+}
+export interface VerificationResult {
+    timestamp: string;
+    valid: boolean;
+    details: string;
+    code: string;
+    challengeResponse?: string;
+}
+export interface VerifyLicenseResponse {
+    data: {
+        license: License;
+        customers: Customer[];
+        products: Product[];
+    };
+    result: VerificationResult;
+}
+export interface HeartbeatResponse {
+    data: {
+        license: {
+            ipLimit: number;
+            hwidLimit: number;
+            expirationType: string;
+        };
+    };
+    result: VerificationResult;
+}
+export interface VerifyLicenseOptions {
+    licenseKey: string;
+    customerId?: string;
+    productId?: string;
+    challenge?: string;
+    version?: string;
+    hardwareIdentifier?: string;
+    branch?: string;
+}
+export interface LicenseHeartbeatOptions {
+    licenseKey: string;
+    hardwareIdentifier: string;
+    customerId?: string;
+    productId?: string;
+    challenge?: string;
+    version?: string;
+    branch?: string;
+}
+export interface DownloadReleaseOptions {
+    licenseKey: string;
+    productId: string;
+    sessionKey: string;
+    hardwareIdentifier: string;
+    version: string;
+    customerId?: string;
+    branch?: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for the Lukittu API client.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "intgate",
+    "version": "1.0.0",
+    "description": "Node.js client library for the IntGate license verification API",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prepare": "npm run build"
+    },
+    "keywords": [
+        "intgate",
+        "license",
+        "verification",
+        "api",
+        "client"
+    ],
+    "author": "IntGate Client Library",
+    "license": "MIT",
+    "dependencies": {
+        "axios": "^1.6.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0",
+        "typescript": "^5.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/intgate/intgate-nodejs"
+    },
+    "homepage": "https://license.intserver.com"
+}

package/src/client.ts

@@ -0,0 +1,272 @@
+/**
+ * IntGate API Client implementation for Node.js/TypeScript.
+ */
+
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { EventEmitter } from 'events';
+import { IntGateAPIError, IntGateValidationError } from './exceptions';
+import {
+    VerifyLicenseOptions,
+    LicenseHeartbeatOptions,
+    DownloadReleaseOptions,
+    VerifyLicenseResponse,
+    HeartbeatResponse,
+} from './types';
+
+/**
+ * Client for interacting with the IntGate license verification API.
+ */
+export class IntGateClient extends EventEmitter {
+    private teamId: string;
+    private baseUrl: string;
+    private axiosInstance: AxiosInstance;
+    private heartbeatTimer: NodeJS.Timeout | null = null;
+    private heartbeatRunning: boolean = false;
+    private lastHeartbeatResult: HeartbeatResponse | null = null;
+
+    /**
+     * Initialize the IntGate client.
+     * @param teamId Your team's UUID from the IntGate dashboard.
+     * @param baseUrl The base URL for the IntGate API (default: https://license.intserver.com/api/v1).
+     */
+    constructor(teamId: string, baseUrl: string = 'https://license.intserver.com/api/v1') {
+        super();
+
+        if (!teamId) {
+            throw new IntGateValidationError('teamId is required');
+        }
+
+        this.teamId = teamId;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.axiosInstance = axios.create({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+
+    /**
+     * Verify a license key with the IntGate backend.
+     *
+     * This endpoint validates a license key and returns license information,
+     * customer data, and product details. Typically called when software starts.
+     *
+     * @param options License verification options
+     * @returns Promise resolving to verification response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async verifyLicense(options: VerifyLicenseOptions): Promise<VerifyLicenseResponse> {
+        if (!options.licenseKey) {
+            throw new IntGateValidationError('licenseKey is required');
+        }
+
+        const payload: any = {
+            licenseKey: options.licenseKey,
+        };
+
+        if (options.customerId) payload.customerId = options.customerId;
+        if (options.productId) payload.productId = options.productId;
+        if (options.challenge) payload.challenge = options.challenge;
+        if (options.version) payload.version = options.version;
+        if (options.hardwareIdentifier) payload.hardwareIdentifier = options.hardwareIdentifier;
+        if (options.branch) payload.branch = options.branch;
+
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/verify`;
+
+        try {
+            const response = await this.axiosInstance.post<VerifyLicenseResponse>(url, payload);
+            return response.data;
+        } catch (error) {
+            this.handleError(error);
+        }
+    }
+
+    /**
+     * Send a heartbeat to determine if a device is still active.
+     *
+     * This endpoint should be called at regular intervals (e.g., every 30 minutes).
+     * It validates the license key similar to verifyLicense.
+     *
+     * @param options Heartbeat options
+     * @returns Promise resolving to heartbeat response
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async licenseHeartbeat(options: LicenseHeartbeatOptions): Promise<HeartbeatResponse> {
+        if (!options.licenseKey) {
+            throw new IntGateValidationError('licenseKey is required');
+        }
+        if (!options.hardwareIdentifier) {
+            throw new IntGateValidationError('hardwareIdentifier is required');
+        }
+
+        const payload: any = {
+            licenseKey: options.licenseKey,
+            hardwareIdentifier: options.hardwareIdentifier,
+        };
+
+        if (options.customerId) payload.customerId = options.customerId;
+        if (options.productId) payload.productId = options.productId;
+        if (options.challenge) payload.challenge = options.challenge;
+        if (options.version) payload.version = options.version;
+        if (options.branch) payload.branch = options.branch;
+
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/heartbeat`;
+
+        try {
+            const response = await this.axiosInstance.post<HeartbeatResponse>(url, payload);
+            return response.data;
+        } catch (error) {
+            this.handleError(error);
+        }
+    }
+
+    /**
+     * Download an encrypted release file.
+     *
+     * This endpoint is primarily for languages that support loading code remotely
+     * (e.g., Java classloaders). The file is encrypted using the provided session key.
+     *
+     * @param options Download release options
+     * @returns Promise resolving to encrypted file content (Buffer)
+     * @throws {IntGateValidationError} If required parameters are invalid
+     * @throws {IntGateAPIError} If the API request fails
+     */
+    async downloadRelease(options: DownloadReleaseOptions): Promise<Buffer> {
+        if (!options.licenseKey) {
+            throw new IntGateValidationError('licenseKey is required');
+        }
+        if (!options.productId) {
+            throw new IntGateValidationError('productId is required');
+        }
+        if (!options.sessionKey) {
+            throw new IntGateValidationError('sessionKey is required');
+        }
+        if (!options.hardwareIdentifier) {
+            throw new IntGateValidationError('hardwareIdentifier is required');
+        }
+        if (!options.version) {
+            throw new IntGateValidationError('version is required');
+        }
+
+        const params: any = {
+            licenseKey: options.licenseKey,
+            productId: options.productId,
+            sessionKey: options.sessionKey,
+            hardwareIdentifier: options.hardwareIdentifier,
+            version: options.version,
+        };
+
+        if (options.customerId) params.customerId = options.customerId;
+        if (options.branch) params.branch = options.branch;
+
+        const url = `${this.baseUrl}/client/teams/${this.teamId}/verification/classloader`;
+
+        try {
+            const response = await this.axiosInstance.get(url, {
+                params,
+                responseType: 'arraybuffer',
+            });
+            return Buffer.from(response.data);
+        } catch (error) {
+            this.handleError(error);
+        }
+    }
+
+    /**
+     * Start automatic heartbeat in the background.
+     * 
+     * The client will emit 'heartbeat' events with the result on success,
+     * and 'heartbeat-error' events on errors.
+     *
+     * @param options Heartbeat options
+     * @param interval Interval in milliseconds between heartbeats (default: 1800000 = 30 minutes)
+     * 
+     * @example
+     * client.startAutomaticHeartbeat({
+     *   licenseKey: 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX',
+     *   hardwareIdentifier: 'device-123'
+     * }, 60000); // Every 1 minute
+     * 
+     * client.on('heartbeat', (result) => {
+     *   console.log('Heartbeat successful:', result);
+     * });
+     * 
+     * client.on('heartbeat-error', (error) => {
+     *   console.error('Heartbeat failed:', error);
+     * });
+     */
+    startAutomaticHeartbeat(options: LicenseHeartbeatOptions, interval: number = 1800000): void {
+        if (this.heartbeatRunning) {
+            throw new IntGateValidationError('Automatic heartbeat is already running');
+        }
+
+        this.heartbeatRunning = true;
+
+        const runHeartbeat = async () => {
+            try {
+                const result = await this.licenseHeartbeat(options);
+                this.lastHeartbeatResult = result;
+                this.emit('heartbeat', result);
+            } catch (error) {
+                this.emit('heartbeat-error', error);
+            }
+
+            if (this.heartbeatRunning) {
+                this.heartbeatTimer = setTimeout(runHeartbeat, interval);
+            }
+        };
+
+        // Run immediately, then schedule
+        runHeartbeat();
+    }
+
+    /**
+     * Stop the automatic heartbeat.
+     */
+    stopAutomaticHeartbeat(): void {
+        this.heartbeatRunning = false;
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+
+    /**
+     * Get the result of the last automatic heartbeat.
+     * 
+     * @returns The last heartbeat result, or null if no heartbeat has run yet
+     */
+    getLastHeartbeatResult(): HeartbeatResponse | null {
+        return this.lastHeartbeatResult;
+    }
+
+    /**
+     * Check if automatic heartbeat is currently running.
+     * 
+     * @returns True if heartbeat is running, false otherwise
+     */
+    isHeartbeatRunning(): boolean {
+        return this.heartbeatRunning;
+    }
+
+    /**
+     * Handle errors from API requests.
+     * @private
+     */
+    private handleError(error: any): never {
+        if (axios.isAxiosError(error)) {
+            const axiosError = error as AxiosError;
+            const statusCode = axiosError.response?.status;
+            const responseData = axiosError.response?.data;
+
+            throw new IntGateAPIError(
+                `API request failed: ${axiosError.message}`,
+                statusCode,
+                responseData
+            );
+        }
+        throw new IntGateAPIError(`Network error: ${error.message}`);
+    }
+}

package/src/exceptions.ts

@@ -0,0 +1,41 @@
+/**
+ * Custom error classes for the IntGate API client.
+ */
+
+/**
+ * Base error class for all IntGate errors.
+ */
+export class IntGateError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'IntGateError';
+        Object.setPrototypeOf(this, IntGateError.prototype);
+    }
+}
+
+/**
+ * Error thrown when the API returns an error response.
+ */
+export class IntGateAPIError extends IntGateError {
+    statusCode?: number;
+    responseData?: any;
+
+    constructor(message: string, statusCode?: number, responseData?: any) {
+        super(message);
+        this.name = 'IntGateAPIError';
+        this.statusCode = statusCode;
+        this.responseData = responseData;
+        Object.setPrototypeOf(this, IntGateAPIError.prototype);
+    }
+}
+
+/**
+ * Error thrown when input validation fails.
+ */
+export class IntGateValidationError extends IntGateError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'IntGateValidationError';
+        Object.setPrototypeOf(this, IntGateValidationError.prototype);
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+/**
+ * IntGate API Client Library for Node.js/TypeScript
+ * A Node.js/TypeScript client library for the IntGate license verification API.
+ */
+
+export { IntGateClient } from './client';
+export { IntGateError, IntGateAPIError, IntGateValidationError } from './exceptions';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,95 @@
+/**
+ * Type definitions for the Lukittu API client.
+ */
+
+export interface LicenseMetadata {
+    key: string;
+    value: string;
+}
+
+export interface License {
+    ipLimit: number;
+    hwidLimit: number;
+    expirationType: 'NEVER' | 'DATE' | 'DAYS';
+    expirationStart?: 'CREATION' | 'ACTIVATION';
+    expirationDate?: string;
+    expirationDays?: number;
+    metadata?: LicenseMetadata[];
+}
+
+export interface Customer {
+    email: string;
+    fullName: string;
+    username: string;
+    metadata?: LicenseMetadata[];
+}
+
+export interface LatestRelease {
+    version: string;
+    createdAt: string;
+}
+
+export interface Product {
+    name: string;
+    url: string;
+    latestRelease?: LatestRelease;
+    metadata?: LicenseMetadata[];
+}
+
+export interface VerificationResult {
+    timestamp: string;
+    valid: boolean;
+    details: string;
+    code: string;
+    challengeResponse?: string;
+}
+
+export interface VerifyLicenseResponse {
+    data: {
+        license: License;
+        customers: Customer[];
+        products: Product[];
+    };
+    result: VerificationResult;
+}
+
+export interface HeartbeatResponse {
+    data: {
+        license: {
+            ipLimit: number;
+            hwidLimit: number;
+            expirationType: string;
+        };
+    };
+    result: VerificationResult;
+}
+
+export interface VerifyLicenseOptions {
+    licenseKey: string;
+    customerId?: string;
+    productId?: string;
+    challenge?: string;
+    version?: string;
+    hardwareIdentifier?: string;
+    branch?: string;
+}
+
+export interface LicenseHeartbeatOptions {
+    licenseKey: string;
+    hardwareIdentifier: string;
+    customerId?: string;
+    productId?: string;
+    challenge?: string;
+    version?: string;
+    branch?: string;
+}
+
+export interface DownloadReleaseOptions {
+    licenseKey: string;
+    productId: string;
+    sessionKey: string;
+    hardwareIdentifier: string;
+    version: string;
+    customerId?: string;
+    branch?: string;
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": [
+            "ES2020"
+        ],
+        "declaration": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}