@tertaut/sdk 0.1.0

package/dist/guard.d.ts

@@ -0,0 +1,58 @@
+import type { ActivationResult, LicenseCheckResult, ProtectOptions, SdkOptions } from './types.js';
+import type { StoredLicenseData } from './storage.js';
+import type { ActivateInput, TertautClient } from './client.js';
+export declare class LicenseGuard {
+    private client;
+    private opts;
+    private storage;
+    private gracePeriodMs;
+    constructor(client: TertautClient, opts: SdkOptions);
+    /**
+     * Mengambil data lisensi yang tersimpan di storage lokal.
+     */
+    getStored(): Promise<StoredLicenseData | null>;
+    /**
+     * Cek cepat apakah software sudah diaktivasi.
+     */
+    isActivated(): Promise<boolean>;
+    /**
+     * 1 BARIS KODE: Aktivasi lisensi software dan langsung simpan ke storage lokal.
+     * Otomatis mengunduh JWKS dan token offline untuk perlindungan tanpa jaringan.
+     *
+     * @example
+     * const res = await tertaut.activate('TRT-ABCD-EFGH-IJKL')
+     * console.log('Aktivasi berhasil:', res.productName)
+     */
+    activate(key: string, input?: Partial<ActivateInput>): Promise<ActivationResult>;
+    /**
+     * 1 BARIS KODE: Cek status lisensi dengan fallback offline otomatis (RS256).
+     * Otomatis membaca storage lokal jika key tidak diberikan.
+     *
+     * @example
+     * const check = await tertaut.guard()
+     * if (!check.valid) {
+     *   console.error('Lisensi tidak sah:', check.reason)
+     * }
+     */
+    guard(options?: ProtectOptions): Promise<LicenseCheckResult>;
+    /**
+     * Memproteksi software — melempar error jika lisensi tidak sah.
+     * Sangat praktis untuk middleware / guard awal aplikasi.
+     *
+     * @example
+     * await tertaut.protect({
+     *   onInvalid: (res) => alert('Aplikasi terkunci: ' + res.reason)
+     * })
+     */
+    protect(options?: ProtectOptions): Promise<LicenseCheckResult>;
+    /**
+     * Melepas lisensi dari perangkat ini dan membersihkan cache lokal.
+     */
+    deactivate(key?: string): Promise<{
+        deactivated: boolean;
+    }>;
+    /**
+     * Verifikasi offline token RS256 lokal + pengecekan grace period.
+     */
+    private verifyOfflineGrace;
+}

package/dist/guard.js

@@ -0,0 +1,255 @@
+import { createUniversalStorage } from './storage.js';
+import { computeFingerprint, verifyOfflineLocally } from './desktop.js';
+export class LicenseGuard {
+    client;
+    opts;
+    storage;
+    gracePeriodMs;
+    constructor(client, opts) {
+        this.client = client;
+        this.opts = opts;
+        this.storage = opts.storage || createUniversalStorage();
+        this.gracePeriodMs = opts.offlineGracePeriodMs ?? 3 * 24 * 60 * 60 * 1000; // 3 hari default
+    }
+    /**
+     * Mengambil data lisensi yang tersimpan di storage lokal.
+     */
+    async getStored() {
+        return this.storage.load(this.opts.productSlug);
+    }
+    /**
+     * Cek cepat apakah software sudah diaktivasi.
+     */
+    async isActivated() {
+        const stored = await this.getStored();
+        return !!(stored && stored.key);
+    }
+    /**
+     * 1 BARIS KODE: Aktivasi lisensi software dan langsung simpan ke storage lokal.
+     * Otomatis mengunduh JWKS dan token offline untuk perlindungan tanpa jaringan.
+     *
+     * @example
+     * const res = await tertaut.activate('TRT-ABCD-EFGH-IJKL')
+     * console.log('Aktivasi berhasil:', res.productName)
+     */
+    async activate(key, input = {}) {
+        const cleanKey = key.trim().toUpperCase();
+        const productSlug = input.productSlug || this.opts.productSlug;
+        const deviceFingerprint = input.deviceFingerprint || (await computeFingerprint());
+        // 1. Panggil server aktivasi
+        const res = await this.client.license.activate({
+            key: cleanKey,
+            productSlug,
+            deviceFingerprint,
+            activationType: input.activationType || 'MACHINE_BIND',
+            deviceName: input.deviceName,
+            domain: input.domain,
+            chromeIdentityId: input.chromeIdentityId,
+        });
+        // 2. Unduh public JWKS sesaat setelah aktivasi untuk verifikasi offline di masa mendatang
+        let jwks = null;
+        try {
+            jwks = await this.client.license.jwks();
+        }
+        catch {
+            /* abaikan bila server JWKS sementara tidak merespon */
+        }
+        // 3. Simpan ke storage lokal
+        await this.storage.save({
+            key: cleanKey,
+            productSlug: res.productSlug || productSlug,
+            offlineToken: res.offlineToken || undefined,
+            jwks,
+            lastValidatedAt: new Date().toISOString(),
+            deviceFingerprint,
+            deviceName: input.deviceName,
+            metadata: {
+                productName: res.productName,
+                expiresAt: res.expiresAt,
+                maxDevices: res.maxDevices,
+                devicesUsed: res.devicesUsed,
+            },
+        });
+        return res;
+    }
+    /**
+     * 1 BARIS KODE: Cek status lisensi dengan fallback offline otomatis (RS256).
+     * Otomatis membaca storage lokal jika key tidak diberikan.
+     *
+     * @example
+     * const check = await tertaut.guard()
+     * if (!check.valid) {
+     *   console.error('Lisensi tidak sah:', check.reason)
+     * }
+     */
+    async guard(options = {}) {
+        const productSlug = options.productSlug || this.opts.productSlug;
+        const stored = await this.storage.load(productSlug);
+        const key = (options.key || stored?.key || this.opts.licenseKey || '').trim().toUpperCase();
+        if (!key && !stored?.offlineToken) {
+            return {
+                valid: false,
+                status: 'NOT_ACTIVATED',
+                reason: 'Lisensi belum diaktivasi pada perangkat ini.',
+                offline: false,
+            };
+        }
+        const fingerprint = stored?.deviceFingerprint || (await computeFingerprint());
+        // JIKA TIDAK MEMAKSA REMOTE DAN SEDANG OFFLINE ATAU INGIN CEK CEPAT
+        if (!options.forceRemote && typeof navigator !== 'undefined' && navigator.onLine === false && stored?.offlineToken) {
+            return this.verifyOfflineGrace(stored, key);
+        }
+        // VALIDASI ONLINE KE SERVER TERTAUT
+        try {
+            const res = await this.client.license.validate({
+                key: key || undefined,
+                productSlug,
+                deviceFingerprint: fingerprint,
+                offlineToken: stored?.offlineToken,
+            });
+            if (res.valid) {
+                // Perbarui timestamp validasi terakhir di cache
+                if (stored) {
+                    stored.lastValidatedAt = new Date().toISOString();
+                    if (res.expiresAt !== undefined) {
+                        stored.metadata = { ...stored.metadata, expiresAt: res.expiresAt };
+                    }
+                    await this.storage.save(stored);
+                }
+                return {
+                    valid: true,
+                    status: res.status || 'ACTIVE',
+                    key: res.key || key,
+                    productName: res.productName || stored?.metadata?.productName,
+                    productSlug: res.productSlug || productSlug,
+                    expiresAt: res.expiresAt,
+                    offline: false,
+                    claims: res.claims,
+                };
+            }
+            // Server mengembalikan bahwa lisensi tidak valid / revoked
+            return {
+                valid: false,
+                status: res.status || 'INVALID',
+                key,
+                reason: 'Lisensi tidak sah, dibatalkan, atau telah melebihi batas perangkat.',
+                offline: false,
+            };
+        }
+        catch (networkError) {
+            // JARINGAN TERPUTUS / SERVER TIMEOUT / OFFLINE
+            // Gunakan token offline RS256 yang tersimpan dengan aman
+            if (stored?.offlineToken) {
+                return this.verifyOfflineGrace(stored, key);
+            }
+            return {
+                valid: false,
+                status: 'INVALID',
+                key,
+                reason: `Gagal memverifikasi lisensi dan tidak ada cache offline: ${networkError?.message || 'Koneksi gagal'}`,
+                offline: false,
+            };
+        }
+    }
+    /**
+     * Memproteksi software — melempar error jika lisensi tidak sah.
+     * Sangat praktis untuk middleware / guard awal aplikasi.
+     *
+     * @example
+     * await tertaut.protect({
+     *   onInvalid: (res) => alert('Aplikasi terkunci: ' + res.reason)
+     * })
+     */
+    async protect(options = {}) {
+        const result = await this.guard(options);
+        if (!result.valid) {
+            if (options.onInvalid) {
+                await options.onInvalid(result);
+            }
+            else {
+                throw new Error(`[Tertaut] Lisensi Tidak Sah (${result.status}): ${result.reason || 'Proteksi aktif'}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Melepas lisensi dari perangkat ini dan membersihkan cache lokal.
+     */
+    async deactivate(key) {
+        const productSlug = this.opts.productSlug;
+        const stored = await this.storage.load(productSlug);
+        const activeKey = (key || stored?.key || this.opts.licenseKey || '').trim().toUpperCase();
+        if (activeKey) {
+            try {
+                const fingerprint = stored?.deviceFingerprint || (await computeFingerprint());
+                await this.client.license.deactivate({
+                    key: activeKey,
+                    deviceFingerprint: fingerprint,
+                });
+            }
+            catch {
+                /* lanjut bersihkan storage lokal */
+            }
+        }
+        await this.storage.clear(productSlug);
+        return { deactivated: true };
+    }
+    /**
+     * Verifikasi offline token RS256 lokal + pengecekan grace period.
+     */
+    async verifyOfflineGrace(stored, key) {
+        if (!stored.offlineToken) {
+            return {
+                valid: false,
+                status: 'INVALID',
+                key,
+                reason: 'Tidak ditemukan token offline.',
+                offline: true,
+            };
+        }
+        try {
+            const offlineRes = await verifyOfflineLocally(stored.offlineToken, stored.jwks || (() => this.client.license.jwks()));
+            if (!offlineRes.valid) {
+                return {
+                    valid: false,
+                    status: 'EXPIRED',
+                    key,
+                    reason: 'Token offline telah kedaluwarsa atau tanda tangan RS256 tidak cocok.',
+                    offline: true,
+                };
+            }
+            // Cek apakah toleransi offline grace period terlampaui
+            const lastVal = new Date(stored.lastValidatedAt).getTime();
+            const now = Date.now();
+            if (now - lastVal > this.gracePeriodMs) {
+                const days = Math.round(this.gracePeriodMs / (24 * 60 * 60 * 1000));
+                return {
+                    valid: false,
+                    status: 'EXPIRED',
+                    key,
+                    reason: `Batas toleransi offline (${days} hari) telah berakhir. Harap sambungkan ke internet untuk menyegarkan lisensi.`,
+                    offline: true,
+                };
+            }
+            return {
+                valid: true,
+                status: 'OFFLINE_GRACE',
+                key,
+                productName: stored.metadata?.productName || offlineRes.claims.productName,
+                productSlug: stored.productSlug || offlineRes.claims.productSlug,
+                expiresAt: offlineRes.expiresAt,
+                offline: true,
+                claims: offlineRes.claims,
+            };
+        }
+        catch (err) {
+            return {
+                valid: false,
+                status: 'INVALID',
+                key,
+                reason: `Verifikasi offline gagal: ${err?.message || 'Kesalahan kriptografi'}`,
+                offline: true,
+            };
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types.js';
+export type { ActivateInput, ValidateInput, DeactivateInput, ChatInput, TertautClient, } from './client.js';
+export { createClient } from './client.js';
+export { LicenseGuard } from './guard.js';
+export { AiClient } from './ai.js';
+export { webhooks, type WebhookVerifyOptions } from './webhooks.js';
+export { createUniversalStorage, type LicenseStorage, type StoredLicenseData, } from './storage.js';
+export { buildDeepLink, computeFingerprint, verifyOfflineLocally, } from './desktop.js';
+export { getIdentityId, saveToSyncStorage, loadFromSyncStorage, persistJournal, getExtensionId, } from './chrome.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export { createClient } from './client.js';
+export { LicenseGuard } from './guard.js';
+export { AiClient } from './ai.js';
+export { webhooks } from './webhooks.js';
+export { createUniversalStorage, } from './storage.js';
+export { buildDeepLink, computeFingerprint, verifyOfflineLocally, } from './desktop.js';
+export { getIdentityId, saveToSyncStorage, loadFromSyncStorage, persistJournal, getExtensionId, } from './chrome.js';

package/dist/jwt.d.ts

@@ -0,0 +1,7 @@
+import type { JwksResponse, OfflineVerifyResult } from './types.js';
+/**
+ * Verifikasi offline RS256 berbasis WebCrypto — TANPA jaringan.
+ * Mencocokkan token (JWT RS256 bertanda "tertaut") terhadap JWKS publik
+ * yang didapat dari GET /api/licenses/.well-known/jwks sesaat sebelum offline.
+ */
+export declare function verifyOfflineToken(token: string, jwks: JwksResponse): Promise<OfflineVerifyResult>;

package/dist/jwt.js

@@ -0,0 +1,61 @@
+function base64UrlToBytes(part) {
+    const b64 = part.replace(/-/g, '+').replace(/_/g, '/');
+    const pad = part.length % 4 === 0 ? '' : '='.repeat(4 - (part.length % 4));
+    const bin = atob(b64 + pad);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        bytes[i] = bin.charCodeAt(i);
+    return bytes;
+}
+/**
+ * Verifikasi offline RS256 berbasis WebCrypto — TANPA jaringan.
+ * Mencocokkan token (JWT RS256 bertanda "tertaut") terhadap JWKS publik
+ * yang didapat dari GET /api/licenses/.well-known/jwks sesaat sebelum offline.
+ */
+export async function verifyOfflineToken(token, jwks) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        return { valid: false, status: 'EXPIRED', claims: {}, expiresAt: null };
+    }
+    const [headerB64, payloadB64, signatureB64] = parts;
+    let header;
+    let claims;
+    try {
+        header = JSON.parse(new TextDecoder().decode(base64UrlToBytes(headerB64)));
+        claims = JSON.parse(new TextDecoder().decode(base64UrlToBytes(payloadB64)));
+    }
+    catch {
+        return { valid: false, status: 'EXPIRED', claims: {}, expiresAt: null };
+    }
+    if (header.alg !== 'RS256') {
+        return { valid: false, status: 'EXPIRED', claims, expiresAt: null };
+    }
+    const key = jwks.keys.find((k) => k.kid === header.kid);
+    if (!key) {
+        return { valid: false, status: 'EXPIRED', claims, expiresAt: null };
+    }
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        throw new Error('WebCrypto (crypto.subtle) tidak tersedia di environment ini');
+    }
+    try {
+        const cryptoKey = await subtle.importKey('jwk', { kty: key.kty, kid: key.kid, n: key.n, e: key.e, alg: 'RS256', use: 'sig' }, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, false, ['verify']);
+        const data = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
+        const signature = base64UrlToBytes(signatureB64);
+        const valid = await subtle.verify('RSASSA-PKCS1-v1_5', cryptoKey, signature, data);
+        if (!valid) {
+            return { valid: false, status: 'EXPIRED', claims, expiresAt: null };
+        }
+        const exp = typeof claims.exp === 'number' ? claims.exp : Number(claims.exp) || 0;
+        const hasExpired = exp !== 0 && Date.now() > exp * 1000;
+        return {
+            valid: true,
+            status: hasExpired ? 'EXPIRED' : 'ACTIVE',
+            claims,
+            expiresAt: hasExpired || exp === 0 ? null : new Date(exp * 1000).toISOString(),
+        };
+    }
+    catch {
+        return { valid: false, status: 'EXPIRED', claims, expiresAt: null };
+    }
+}

package/dist/storage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Universal Storage Adapter untuk Tertaut SDK.
+ * Otomatis mendeteksi lingkungan: Browser, Chrome Extension, Node.js, Electron, atau CLI.
+ */
+export interface StoredLicenseData {
+    key: string;
+    productSlug?: string;
+    offlineToken?: string;
+    jwks?: any;
+    lastValidatedAt: string;
+    deviceFingerprint?: string;
+    deviceName?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LicenseStorage {
+    load(productSlug?: string): Promise<StoredLicenseData | null>;
+    save(data: StoredLicenseData): Promise<void>;
+    clear(productSlug?: string): Promise<void>;
+}
+/**
+ * Resolves the most appropriate storage engine for the current runtime environment.
+ */
+export declare function createUniversalStorage(): LicenseStorage;

package/dist/storage.js

@@ -0,0 +1,189 @@
+/**
+ * Universal Storage Adapter untuk Tertaut SDK.
+ * Otomatis mendeteksi lingkungan: Browser, Chrome Extension, Node.js, Electron, atau CLI.
+ */
+// In-memory fallback
+let memoryStorage = {};
+function getStorageKey(productSlug) {
+    return productSlug ? `tertaut_license_${productSlug}` : 'tertaut_license_default';
+}
+/**
+ * 1. Storage untuk Web Browser (localStorage)
+ */
+class BrowserStorage {
+    async load(productSlug) {
+        if (typeof window === 'undefined' || !window.localStorage)
+            return null;
+        try {
+            const raw = window.localStorage.getItem(getStorageKey(productSlug));
+            return raw ? JSON.parse(raw) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(data) {
+        if (typeof window === 'undefined' || !window.localStorage)
+            return;
+        try {
+            window.localStorage.setItem(getStorageKey(data.productSlug), JSON.stringify(data));
+        }
+        catch {
+            /* ignore quota errors */
+        }
+    }
+    async clear(productSlug) {
+        if (typeof window === 'undefined' || !window.localStorage)
+            return;
+        try {
+            window.localStorage.removeItem(getStorageKey(productSlug));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/**
+ * 2. Storage untuk Chrome Extension (chrome.storage.sync / local)
+ */
+class ChromeStorage {
+    getArea() {
+        const ch = globalThis.chrome;
+        return ch?.storage?.sync || ch?.storage?.local || null;
+    }
+    async load(productSlug) {
+        const area = this.getArea();
+        if (!area)
+            return null;
+        const key = getStorageKey(productSlug);
+        return new Promise((resolve) => {
+            area.get(key, (items) => {
+                resolve(items && items[key] ? items[key] : null);
+            });
+        });
+    }
+    async save(data) {
+        const area = this.getArea();
+        if (!area)
+            return;
+        const key = getStorageKey(data.productSlug);
+        return new Promise((resolve) => {
+            area.set({ [key]: data }, () => resolve());
+        });
+    }
+    async clear(productSlug) {
+        const area = this.getArea();
+        if (!area)
+            return;
+        const key = getStorageKey(productSlug);
+        return new Promise((resolve) => {
+            area.remove(key, () => resolve());
+        });
+    }
+}
+/**
+ * 3. Storage untuk Node.js / Electron / CLI (File JSON di ~/.tertaut/)
+ */
+class NodeFileStorage {
+    async getFs() {
+        try {
+            // Dynamic import to prevent bundler errors in browser environments
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const os = await import('node:os');
+            return { fs, path, os };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getFilePath(productSlug) {
+        const node = await this.getFs();
+        if (!node)
+            return null;
+        const home = node.os.homedir();
+        const dir = node.path.join(home, '.tertaut');
+        try {
+            if (!node.fs.existsSync(dir)) {
+                node.fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        catch {
+            return null;
+        }
+        const safeName = (productSlug || 'default').replace(/[^a-zA-Z0-9_-]/g, '_');
+        return node.path.join(dir, `license_${safeName}.json`);
+    }
+    async load(productSlug) {
+        try {
+            const node = await this.getFs();
+            const filePath = await this.getFilePath(productSlug);
+            if (!node || !filePath || !node.fs.existsSync(filePath))
+                return null;
+            const raw = node.fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(data) {
+        try {
+            const node = await this.getFs();
+            const filePath = await this.getFilePath(data.productSlug);
+            if (!node || !filePath)
+                return;
+            node.fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch {
+            /* fallback ke memory */
+        }
+    }
+    async clear(productSlug) {
+        try {
+            const node = await this.getFs();
+            const filePath = await this.getFilePath(productSlug);
+            if (!node || !filePath || !node.fs.existsSync(filePath))
+                return;
+            node.fs.unlinkSync(filePath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/**
+ * 4. In-Memory Storage (Fallback aman)
+ */
+class MemoryStorage {
+    async load(productSlug) {
+        return memoryStorage[getStorageKey(productSlug)] || null;
+    }
+    async save(data) {
+        memoryStorage[getStorageKey(data.productSlug)] = data;
+    }
+    async clear(productSlug) {
+        delete memoryStorage[getStorageKey(productSlug)];
+    }
+}
+/**
+ * Resolves the most appropriate storage engine for the current runtime environment.
+ */
+export function createUniversalStorage() {
+    // 1. Chrome Extension environment
+    const ch = globalThis.chrome;
+    if (ch?.storage?.sync || ch?.storage?.local) {
+        return new ChromeStorage();
+    }
+    // 2. Browser environment
+    if (typeof window !== 'undefined' && window.localStorage) {
+        return new BrowserStorage();
+    }
+    // 3. Node.js / Electron / Bun environment
+    const isNodeLike = typeof process !== 'undefined' && process.versions && (process.versions.node || process.versions.bun);
+    if (isNodeLike) {
+        return new NodeFileStorage();
+    }
+    // 4. Fallback memory
+    return new MemoryStorage();
+}