Node.js SDK

npm install @authforgecc/sdk

import { AuthForgeClient } from "@authforgecc/sdk";

import { AuthForgeClient } from "@authforgecc/sdk";
import * as readline from "node:readline/promises";

const client = new AuthForgeClient({
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
});

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const key = await rl.question("Enter license key: ");
rl.close();

if (await client.login(key)) {
    console.log("Authenticated!");
    // Your app logic here - the signed session covers the grace period
} else {
    console.error("Invalid license key.");
    process.exit(1);
}

const client = new AuthForgeClient({
    appId: "YOUR_APP_ID",                     // Required - from dashboard
    appSecret: "YOUR_APP_SECRET",             // Required for online login/validate; omit or "" for loginFromFile only
    publicKey: "YOUR_PUBLIC_KEY",             // Required - Ed25519 public key from your AuthForge dashboard (base64)
    onlineHeartbeat: false,                   // Optional - true enables periodic online check-ins (/auth/heartbeat)
    heartbeatInterval: 900,                   // Optional - background timer cadence (check-ins when online, local session checks otherwise)
    apiBaseUrl: "https://auth.authforge.cc",  // Optional
    onFailure: null,                          // Optional - callback(reason, error); check-in errors are AuthForgeError with code / transient
    requestTimeout: 15,                       // Optional - HTTP timeout in seconds
    ttlSeconds: null,                         // Optional - grace period (session TTL). null = server default (24h). Clamped to [3600, 604800].
    hwidOverride: null,                       // Optional - custom identity (for example "tg:123456789")
});

const success = await client.login(licenseKey);

const result = await client.validateLicense(licenseKey);
if (result.valid) {
  console.log(result.sessionToken, result.expiresIn, result.appVariables, result.licenseVariables);
} else {
  console.error(result.code, result.error);
}

import { AuthForgeClient, AuthForgeError } from "@authforgecc/sdk";

const licenseLost = new AbortController();

function handleFailure(reason, error) {
    if (reason === "heartbeat_failed" && error instanceof AuthForgeError && error.transient) {
        // No verdict on the license (outage, rate limit, credits, proxy): keep
        // running. The SDK checks in again every heartbeatInterval and reports
        // session_expired (definitive) once the ttlSeconds grace period is used up.
        console.warn(`AuthForge check-in failed (${error.code}), retrying`);
        return;
    }
    // Definitive: the session is already cleared (client.isAuthenticated() === false).
    console.error(`License check failed: ${reason} (${error?.code ?? error?.message})`);
    licenseLost.abort(error); // signal the app instead of exiting here
}

const client = new AuthForgeClient({
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
    onlineHeartbeat: true,
    ttlSeconds: 3600, // retry window for transient check-in failures
    onFailure: handleFailure,
});

licenseLost.signal.addEventListener(
    "abort",
    async () => {
        await saveApplicationState();
        server.close(); // close whatever keeps the event loop alive (servers, intervals, sockets)
        client.logout();
        process.exitCode = 1; // Node exits once nothing is left running
    },
    { once: true },
);

if (await client.login(licenseKey)) {
    // App-wide variables (set in dashboard or API)
    const appVars = client.appVariables;
    if (appVars.maintenanceMode) {
        console.log("Server is under maintenance.");
        process.exit(0);
    }

    // Per-license variables
    const plan = client.licenseVariables.plan ?? "basic";
    if (plan === "pro") {
        enableProFeatures();
    }
}

// Default: activate online, then run through the grace period (24h by default)
const client = new AuthForgeClient({
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
    ttlSeconds: 259200, // Optional: extend the grace period to 3 days (clamped to 1h-7d)
});

// Strict policy: periodic online check-ins for fast revocation
const strictClient = new AuthForgeClient({
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
    onlineHeartbeat: true,
    heartbeatInterval: 900, // 15 minutes (default)
});

const client = new AuthForgeClient({ appId: "APP_ID", publicKey: "PUBLIC_KEY" });

// Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
client.writeActivationRequest("./machine.authforge-request");

// Step 2 (customer machine, after you deliver the file): path or armored text.
if (client.loginFromFile("./license.authforge")) {
  console.log("Offline license valid until", client.getOfflineLicense().expiresAt ?? "forever");
  console.log(client.getLicenseVariables());
}

import fs from "node:fs";
import { AuthForgeClient, AuthForgeError } from "@authforgecc/sdk";

const LICENSE_PATH = appDataPath("license.authforge");

const client = new AuthForgeClient({ appId: "YOUR_APP_ID", appSecret: "YOUR_APP_SECRET", publicKey: "YOUR_PUBLIC_KEY" });

if (!(fs.existsSync(LICENSE_PATH) && client.loginFromFile(LICENSE_PATH))) {
  // No file yet, or it is for other hardware: ask for the key and activate once.
  const key = await promptForKey();
  try {
    await client.activateOffline(key, { path: LICENSE_PATH }); // resolves true
  } catch (error) {
    const code = error instanceof AuthForgeError ? error.code : "unknown_error";
    showError(code === "offline_activation_limit_reached"
      ? "This key is already activated on the maximum number of computers. Contact support."
      : `Activation failed (${code}).`);
    process.exit(1);
  }
}

import { AuthForgeClient, AuthForgeError } from "@authforgecc/sdk";
import * as readline from "node:readline/promises";

function saveState() {
    console.log("Saving application state...");
    // Your save logic here
}

const licenseLost = new AbortController();

const client = new AuthForgeClient({
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY",
    onlineHeartbeat: true, // Optional strict policy: check in every 15 minutes
    heartbeatInterval: 900,
    onFailure: (reason, exception) => {
        if (reason === "heartbeat_failed" && exception instanceof AuthForgeError && exception.transient) {
            console.warn(`Check-in failed (${exception.code}); retrying on the next interval`);
            return;
        }
        console.error(`Auth failure: ${reason}`);
        if (exception) {
            console.error(`Detail: ${exception.message ?? exception}`);
        }
        licenseLost.abort(exception); // signal the app instead of exiting here
    },
});

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const key = await rl.question("Enter license key: ");
rl.close();

if (!(await client.login(key))) {
    console.error("Invalid license key.");
    process.exit(1);
}

console.log("Licensed and running!");

const minVersion = client.appVariables.minVersion;
if (minVersion && APP_VERSION < minVersion) {
    console.error(`Please update to version ${minVersion} or later.`);
    process.exit(1);
}

const appLoop = setInterval(() => {
    // Your app logic here
}, 1000);

function shutdown(exitCode) {
    clearInterval(appLoop);
    saveState();
    client.logout();
    process.exitCode = exitCode; // Node exits once nothing is left running
}

licenseLost.signal.addEventListener("abort", () => shutdown(1), { once: true });
process.once("SIGINT", () => shutdown(0));