@hexabot-ai/api 3.0.0-alpha.3 → 3.1.1-alpha.0

package/dist/license/services/lemon-squeezy.service.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LemonSqueezyService = exports.LEMON_SQUEEZY_API_BASE_URL = void 0;
+const axios_1 = require("@nestjs/axios");
+const common_1 = require("@nestjs/common");
+const axios_2 = require("axios");
+const uuid_1 = require("uuid");
+exports.LEMON_SQUEEZY_API_BASE_URL = 'https://api.lemonsqueezy.com';
+let LemonSqueezyService = class LemonSqueezyService {
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    async validate(licenseKey, instanceId) {
+        const { data, status } = await this.httpService.axiosRef.post(`${exports.LEMON_SQUEEZY_API_BASE_URL}/v1/licenses/validate`, { license_key: licenseKey, instance_id: instanceId }, {
+            headers: {
+                Accept: 'application/json',
+            },
+            validateStatus: (responseStatus) => responseStatus >= 200 && responseStatus < 500,
+        });
+        if (typeof data?.valid !== 'boolean') {
+            throw new Error(`Unexpected license validation response from Lemon Squeezy (status=${status}).`);
+        }
+        return data;
+    }
+    async activate(licenseKey) {
+        const { data } = await this.httpService.axiosRef.post(`${exports.LEMON_SQUEEZY_API_BASE_URL}/v1/licenses/activate`, {
+            license_key: licenseKey,
+            instance_name: (0, uuid_1.v4)(),
+        }, {
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        return data;
+    }
+    async deactivate(licenseKey, instanceId) {
+        const { data } = await this.httpService.axiosRef.post(`${exports.LEMON_SQUEEZY_API_BASE_URL}/v1/licenses/deactivate`, {
+            license_key: licenseKey,
+            instance_id: instanceId,
+        }, {
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        return data;
+    }
+    extractAxiosError(error) {
+        if (error instanceof axios_2.AxiosError) {
+            const details = typeof error.response?.data === 'object' && error.response?.data
+                ? JSON.stringify(error.response.data)
+                : error.message;
+            return `License API call failed: ${details}`;
+        }
+        if (error instanceof Error) {
+            return `License API call failed: ${error.message}`;
+        }
+        return 'License API call failed due to an unknown error';
+    }
+};
+exports.LemonSqueezyService = LemonSqueezyService;
+exports.LemonSqueezyService = LemonSqueezyService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [axios_1.HttpService])
+], LemonSqueezyService);
+//# sourceMappingURL=lemon-squeezy.service.js.map

package/dist/license/services/lemon-squeezy.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lemon-squeezy.service.js","sourceRoot":"","sources":["../../../src/license/services/lemon-squeezy.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAMA,yCAA4C;AAC5C,2CAA4C;AAC5C,iCAAmC;AACnC,+BAAoC;AAQvB,QAAA,0BAA0B,GAAG,8BAA8B,CAAC;AAGlE,IAAM,mBAAmB,GAAzB,MAAM,mBAAmB;IAC9B,YAA6B,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IAAG,CAAC;IAEzD,KAAK,CAAC,QAAQ,CAAC,UAAkB,EAAE,UAAmB;QACpD,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GACpB,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAClC,GAAG,kCAA0B,uBAAuB,EACpD,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,EACpD;YACE,OAAO,EAAE;gBACP,MAAM,EAAE,kBAAkB;aAC3B;YAGD,cAAc,EAAE,CAAC,cAAc,EAAE,EAAE,CACjC,cAAc,IAAI,GAAG,IAAI,cAAc,GAAG,GAAG;SAChD,CACF,CAAC;QAEJ,IAAI,OAAO,IAAI,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,qEAAqE,MAAM,IAAI,CAChF,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,UAAkB;QAC/B,MAAM,EAAE,IAAI,EAAE,GACZ,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAClC,GAAG,kCAA0B,uBAAuB,EACpD;YACE,WAAW,EAAE,UAAU;YACvB,aAAa,EAAE,IAAA,SAAM,GAAE;SACxB,EACD;YACE,OAAO,EAAE;gBACP,MAAM,EAAE,kBAAkB;aAC3B;SACF,CACF,CAAC;QAEJ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,UAAkB,EAAE,UAAkB;QACrD,MAAM,EAAE,IAAI,EAAE,GACZ,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAClC,GAAG,kCAA0B,yBAAyB,EACtD;YACE,WAAW,EAAE,UAAU;YACvB,WAAW,EAAE,UAAU;SACxB,EACD;YACE,OAAO,EAAE;gBACP,MAAM,EAAE,kBAAkB;aAC3B;SACF,CACF,CAAC;QAEJ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,iBAAiB,CAAC,KAAc;QAC9B,IAAI,KAAK,YAAY,kBAAU,EAAE,CAAC;YAChC,MAAM,OAAO,GACX,OAAO,KAAK,CAAC,QAAQ,EAAE,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,QAAQ,EAAE,IAAI;gBAC9D,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACrC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;YAEpB,OAAO,4BAA4B,OAAO,EAAE,CAAC;QAC/C,CAAC;QAED,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,OAAO,4BAA4B,KAAK,CAAC,OAAO,EAAE,CAAC;QACrD,CAAC;QAED,OAAO,iDAAiD,CAAC;IAC3D,CAAC;CACF,CAAA;AAhFY,kDAAmB;8BAAnB,mBAAmB;IAD/B,IAAA,mBAAU,GAAE;qCAE+B,mBAAW;GAD1C,mBAAmB,CAgF/B"}

package/dist/license/services/license-orm-listener.service.d.ts

@@ -0,0 +1,12 @@
+import { DataSource, EntitySubscriberInterface, InsertEvent, ObjectLiteral } from 'typeorm';
+import { LicenseService } from './license.service';
+export declare class LicenseOrmListener implements EntitySubscriberInterface {
+    private readonly dataSource;
+    private readonly licenseService;
+    private readonly rules;
+    constructor(dataSource: DataSource, licenseService: LicenseService);
+    private registerAsSubscriber;
+    private resolveRule;
+    private buildLimitMessage;
+    beforeInsert(event: InsertEvent<ObjectLiteral>): Promise<void>;
+}

package/dist/license/services/license-orm-listener.service.js

@@ -0,0 +1,80 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseOrmListener = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const user_entity_1 = require("../../user/entities/user.entity");
+const workflow_entity_1 = require("../../workflow/entities/workflow.entity");
+const license_quota_1 = require("../types/license-quota");
+const license_service_1 = require("./license.service");
+let LicenseOrmListener = class LicenseOrmListener {
+    constructor(dataSource, licenseService) {
+        this.dataSource = dataSource;
+        this.licenseService = licenseService;
+        this.rules = [
+            {
+                target: user_entity_1.UserOrmEntity,
+                resource: 'users',
+            },
+            {
+                target: workflow_entity_1.WorkflowOrmEntity,
+                resource: 'workflows',
+            },
+        ];
+        this.registerAsSubscriber();
+    }
+    registerAsSubscriber() {
+        const alreadyRegistered = this.dataSource.subscribers.some((subscriber) => subscriber === this);
+        if (!alreadyRegistered) {
+            this.dataSource.subscribers.push(this);
+        }
+    }
+    resolveRule(event) {
+        const targetName = event.metadata.targetName ?? event.metadata.name;
+        return this.rules.find((rule) => rule.target === event.metadata.target ||
+            (typeof rule.target === 'function' && rule.target.name === targetName));
+    }
+    buildLimitMessage(resource, tier, limit) {
+        const resourceName = license_quota_1.LICENSE_QUOTA_RESOURCE_NAMES[resource];
+        const resourceWithCardinality = limit === 1 ? resourceName : resource;
+        return `Cannot create ${resourceName}: ${tier} plan allows up to ${limit} ${resourceWithCardinality}.`;
+    }
+    async beforeInsert(event) {
+        const rule = this.resolveRule(event);
+        if (!rule) {
+            return;
+        }
+        const tier = (0, license_quota_1.resolveLicenseQuotaTier)(this.licenseService.getStatus(), this.licenseService.getPlan());
+        const limit = license_quota_1.LICENSE_QUOTA_LIMITS[rule.resource][tier];
+        if (typeof limit !== 'number') {
+            return;
+        }
+        const where = rule.buildWhere?.(event);
+        const currentCount = await event.manager.count(rule.target, where ? { where } : undefined);
+        if (currentCount >= limit) {
+            throw new common_1.ForbiddenException(this.buildLimitMessage(rule.resource, tier, limit));
+        }
+    }
+};
+exports.LicenseOrmListener = LicenseOrmListener;
+exports.LicenseOrmListener = LicenseOrmListener = __decorate([
+    (0, common_1.Injectable)(),
+    (0, typeorm_2.EventSubscriber)(),
+    __param(0, (0, typeorm_1.InjectDataSource)()),
+    __metadata("design:paramtypes", [typeorm_2.DataSource,
+        license_service_1.LicenseService])
+], LicenseOrmListener);
+//# sourceMappingURL=license-orm-listener.service.js.map

package/dist/license/services/license-orm-listener.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"license-orm-listener.service.js","sourceRoot":"","sources":["../../../src/license/services/license-orm-listener.service.ts"],"names":[],"mappings":"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"}

package/dist/license/services/license.service.d.ts

@@ -0,0 +1,55 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { LoggerService } from '@/logger/logger.service';
+import { SettingOrmEntity } from '@/setting/entities/setting.entity';
+import { MetadataService } from '@/setting/services/metadata.service';
+import { SettingService } from '@/setting/services/setting.service';
+import { UpdateEntityEvent } from '@/utils/types/entity-event.types';
+import { LicenseFeature, LicensePlan, LicenseSnapshot, LicenseStatus } from '../types/license-feature.enum';
+import { LemonSqueezyService } from './lemon-squeezy.service';
+type RefreshSource = 'bootstrap' | 'setting';
+export declare class LicenseService implements OnApplicationBootstrap {
+    private readonly apiService;
+    private readonly settingService;
+    private readonly metadataService;
+    private readonly logger;
+    private readonly dataSource;
+    private readonly features;
+    private status;
+    private plan;
+    private lastError;
+    private activationLimit;
+    private activationUsage;
+    constructor(apiService: LemonSqueezyService, settingService: SettingService, metadataService: MetadataService, logger: LoggerService, dataSource: DataSource);
+    onApplicationBootstrap(): Promise<void>;
+    hasFeature(feature: LicenseFeature): boolean;
+    getLastError(): string | null;
+    getStatus(): LicenseStatus;
+    getPlan(): LicensePlan;
+    getActivationLimit(): number | null;
+    getActivationUsage(): number | null;
+    getSnapshot(): Promise<LicenseSnapshot>;
+    private buildQuotaSnapshot;
+    refresh(source?: RefreshSource): Promise<void>;
+    handleLicenseKeyUpdate(event: UpdateEntityEvent<SettingOrmEntity>): Promise<void>;
+    deactivate(licenseKey: string, reason?: string): Promise<boolean>;
+    private validateCandidateLicense;
+    private extractBadRequestMessage;
+    private restoreOldLicense;
+    private getLicenseKey;
+    private getInstanceId;
+    private removeInstanceId;
+    private upsertInstanceId;
+    private normalizeLicenseKey;
+    private disableAllFeatures;
+    private syncFeatureState;
+    private planSatisfies;
+    private hasAvailableActivationSlot;
+    private applyActivatedState;
+    private updateUsageAndPlan;
+    private applyInactiveState;
+    private clearError;
+    private setError;
+    private inferPlan;
+}
+export {};

package/dist/license/services/license.service.js

@@ -0,0 +1,429 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseService = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const logger_service_1 = require("../../logger/logger.service");
+const default_settings_1 = require("../../setting/default.settings");
+const metadata_service_1 = require("../../setting/services/metadata.service");
+const setting_service_1 = require("../../setting/services/setting.service");
+const user_entity_1 = require("../../user/entities/user.entity");
+const workflow_entity_1 = require("../../workflow/entities/workflow.entity");
+const license_feature_enum_1 = require("../types/license-feature.enum");
+const license_quota_1 = require("../types/license-quota");
+const lemon_squeezy_service_1 = require("./lemon-squeezy.service");
+const INSTANCE_ID_METADATA_KEY = 'instance_id';
+let LicenseService = class LicenseService {
+    constructor(apiService, settingService, metadataService, logger, dataSource) {
+        this.apiService = apiService;
+        this.settingService = settingService;
+        this.metadataService = metadataService;
+        this.logger = logger;
+        this.dataSource = dataSource;
+        this.features = new Map();
+        this.status = 'inactive';
+        this.plan = 'unknown';
+        this.lastError = null;
+        this.activationLimit = null;
+        this.activationUsage = null;
+        this.disableAllFeatures();
+    }
+    async onApplicationBootstrap() {
+        await this.refresh('bootstrap');
+    }
+    hasFeature(feature) {
+        return this.features.get(feature) === true;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getPlan() {
+        return this.plan;
+    }
+    getActivationLimit() {
+        return this.activationLimit;
+    }
+    getActivationUsage() {
+        return this.activationUsage;
+    }
+    async getSnapshot() {
+        const quotas = await this.buildQuotaSnapshot();
+        return {
+            status: this.status,
+            plan: this.plan,
+            activationLimit: this.activationLimit,
+            activationUsage: this.activationUsage,
+            lastError: this.lastError,
+            quotas,
+        };
+    }
+    async buildQuotaSnapshot() {
+        const tier = (0, license_quota_1.resolveLicenseQuotaTier)(this.status, this.plan);
+        const [usersCount, workflowsCount] = await Promise.all([
+            this.dataSource.getRepository(user_entity_1.UserOrmEntity).count(),
+            this.dataSource.getRepository(workflow_entity_1.WorkflowOrmEntity).count(),
+        ]);
+        const counts = {
+            users: usersCount,
+            workflows: workflowsCount,
+        };
+        const resources = Object.entries(license_quota_1.LICENSE_QUOTA_LIMITS).reduce((acc, [resource, limits]) => {
+            const typedResource = resource;
+            const used = counts[typedResource];
+            const limit = limits[tier];
+            const remaining = typeof limit === 'number' ? Math.max(limit - used, 0) : null;
+            acc[typedResource] = {
+                limit,
+                used,
+                remaining,
+                reached: typeof limit === 'number' ? used >= limit : false,
+            };
+            return acc;
+        }, {});
+        return {
+            tier,
+            resources,
+        };
+    }
+    async refresh(source = 'bootstrap') {
+        try {
+            const key = await this.getLicenseKey();
+            if (!key) {
+                this.applyInactiveState('undefined', 'unknown', source === 'bootstrap'
+                    ? 'No license key set (bootstrap).'
+                    : 'No license key set.');
+                return;
+            }
+            const instanceId = await this.getInstanceId();
+            const validated = await this.apiService.validate(key, instanceId);
+            if (!validated.valid || !validated.license_key) {
+                this.applyInactiveState('invalid', 'unknown', source === 'bootstrap'
+                    ? 'Invalid license key (bootstrap).'
+                    : 'Invalid license key.');
+                return;
+            }
+            const licenseKey = validated.license_key;
+            const currentPlan = this.inferPlan(validated.meta);
+            if (licenseKey.status === 'expired' || licenseKey.status === 'disabled') {
+                this.applyInactiveState(licenseKey.status, currentPlan, source === 'bootstrap'
+                    ? `License key ${licenseKey.status} (bootstrap).`
+                    : `License key ${licenseKey.status}.`);
+                return;
+            }
+            if (licenseKey.status !== 'active' && licenseKey.status !== 'inactive') {
+                this.applyInactiveState('inactive', currentPlan, `License key status \"${licenseKey.status}\" is not activatable.`);
+                return;
+            }
+            if (licenseKey.status === 'active' && validated.instance?.id) {
+                await this.applyActivatedState(validated, source);
+                return;
+            }
+            if (!this.hasAvailableActivationSlot(licenseKey)) {
+                this.applyInactiveState('inactive', currentPlan, source === 'bootstrap'
+                    ? `Activation limit reached during bootstrap (usage=${licenseKey.activation_usage ?? 'n/a'}/${licenseKey.activation_limit ?? 'n/a'}).`
+                    : `Activation limit reached (usage=${licenseKey.activation_usage ?? 'n/a'}/${licenseKey.activation_limit ?? 'n/a'}).`);
+                return;
+            }
+            const activated = await this.apiService.activate(licenseKey.key);
+            if (!activated.activated) {
+                this.applyInactiveState('inactive', currentPlan, activated.error ||
+                    `Unable to activate license (status=${activated.license_key?.status ?? 'unknown'}).`);
+                return;
+            }
+            await this.applyActivatedState(activated, source);
+        }
+        catch (err) {
+            const msg = this.apiService.extractAxiosError(err);
+            this.applyInactiveState('error', 'unknown', `${source === 'bootstrap' ? 'Bootstrap' : 'Refresh'} failed: ${msg}`);
+        }
+    }
+    async handleLicenseKeyUpdate(event) {
+        const previous = event.databaseEntity;
+        const next = event.entity;
+        const group = next?.group ?? previous?.group;
+        const label = next?.label ?? previous?.label;
+        if (group !== default_settings_1.CHATBOT_SETTINGS_GROUP || label !== 'license_key') {
+            return;
+        }
+        const oldKey = this.normalizeLicenseKey(previous?.value);
+        const newKey = this.normalizeLicenseKey(next?.value);
+        if (newKey === oldKey) {
+            await this.refresh('setting');
+            return;
+        }
+        if (!newKey) {
+            const isSuccess = oldKey
+                ? await this.deactivate(oldKey, 'License key removed.')
+                : true;
+            if (!isSuccess) {
+                throw new common_1.BadRequestException('Failed to remove existing license key.');
+            }
+            this.applyInactiveState('undefined', 'unknown', 'No license key set.');
+            return;
+        }
+        let validLicense;
+        try {
+            validLicense = await this.validateCandidateLicense(newKey);
+        }
+        catch (err) {
+            if (!oldKey) {
+                if (err instanceof common_1.BadRequestException) {
+                    this.applyInactiveState('invalid', 'unknown', this.extractBadRequestMessage(err, 'Invalid license key.'));
+                }
+                else {
+                    this.applyInactiveState('error', 'unknown', `Unable to validate the license key - ${this.apiService.extractAxiosError(err)}`);
+                }
+            }
+            else {
+                await this.refresh('setting');
+            }
+            throw err;
+        }
+        const newLicenseKey = validLicense.license_key;
+        if (oldKey) {
+            const deactivated = await this.deactivate(oldKey, 'License will rotate.');
+            if (!deactivated) {
+                throw new common_1.BadRequestException('Failed to deactivate existing license key before rotation.');
+            }
+        }
+        let activation;
+        try {
+            activation = await this.apiService.activate(newLicenseKey.key);
+        }
+        catch (err) {
+            await this.restoreOldLicense(oldKey);
+            throw new common_1.BadRequestException(`Unable to activate the license key - ${this.apiService.extractAxiosError(err)}`);
+        }
+        if (!activation.activated) {
+            await this.restoreOldLicense(oldKey);
+            throw new common_1.BadRequestException(activation.error ||
+                'Unable to activate the license key, please try again later or contact support.');
+        }
+        await this.applyActivatedState(activation, 'setting');
+    }
+    async deactivate(licenseKey, reason) {
+        try {
+            const instanceId = await this.getInstanceId();
+            const validated = await this.apiService.validate(licenseKey, instanceId);
+            if (!validated.valid) {
+                this.logger.warn('Cannot deactivate invalid license key', validated);
+                this.applyInactiveState('error', 'unknown', reason);
+                return true;
+            }
+            const currentPlan = this.inferPlan(validated.meta);
+            if (validated.license_key?.status === 'active' && instanceId) {
+                const result = await this.apiService.deactivate(licenseKey, instanceId);
+                if (!result.deactivated) {
+                    throw new Error(result.error || 'Failed to deactivate license key.');
+                }
+                await this.removeInstanceId();
+                this.logger.debug('License key successfully deactivated');
+                this.applyInactiveState('inactive', currentPlan, reason);
+            }
+            else {
+                this.logger.warn('Cannot deactivate license key', validated);
+                this.applyInactiveState('inactive', currentPlan, reason);
+            }
+            return true;
+        }
+        catch (err) {
+            this.logger.error('Unable to deactivate license key', err);
+            return false;
+        }
+    }
+    async validateCandidateLicense(licenseKey) {
+        let validation;
+        try {
+            validation = await this.apiService.validate(licenseKey);
+        }
+        catch (err) {
+            throw new common_1.BadRequestException(`New license key validation failed - ${this.apiService.extractAxiosError(err)}`);
+        }
+        if (!validation.valid || !validation.license_key) {
+            throw new common_1.BadRequestException('Invalid license key.');
+        }
+        if (validation.license_key.status === 'expired') {
+            throw new common_1.BadRequestException('License key has expired, please renew your subscription and try again.');
+        }
+        if (validation.license_key.status === 'disabled') {
+            throw new common_1.BadRequestException('License key has been disabled.');
+        }
+        if (validation.license_key.status !== 'active' &&
+            validation.license_key.status !== 'inactive') {
+            throw new common_1.BadRequestException(`Unsupported license key status \"${validation.license_key.status}\".`);
+        }
+        if (!this.hasAvailableActivationSlot(validation.license_key)) {
+            throw new common_1.BadRequestException('License key activation limit reached.');
+        }
+        return validation;
+    }
+    extractBadRequestMessage(error, fallback) {
+        const response = error.getResponse();
+        if (typeof response === 'string') {
+            return response;
+        }
+        if (response && typeof response === 'object') {
+            const message = response.message;
+            if (Array.isArray(message)) {
+                return message.filter(Boolean).join(', ') || fallback;
+            }
+            if (typeof message === 'string') {
+                return message;
+            }
+        }
+        return fallback;
+    }
+    async restoreOldLicense(oldKey) {
+        if (!oldKey) {
+            return;
+        }
+        try {
+            const restored = await this.apiService.activate(oldKey);
+            if (restored.activated) {
+                await this.applyActivatedState(restored, 'setting');
+            }
+            else {
+                this.logger.warn('Unable to restore previous license key after failure');
+            }
+        }
+        catch (err) {
+            this.logger.error('Unable to restore previous license key', err);
+        }
+    }
+    async getLicenseKey() {
+        await this.settingService.clearCache();
+        const settings = await this.settingService.getSettings();
+        return this.normalizeLicenseKey(settings.chatbot_settings?.license_key);
+    }
+    async getInstanceId() {
+        const metadata = await this.metadataService.findOne({
+            where: { name: INSTANCE_ID_METADATA_KEY },
+        });
+        return this.normalizeLicenseKey(metadata?.value);
+    }
+    async removeInstanceId() {
+        return await this.metadataService.deleteOne({
+            where: { name: INSTANCE_ID_METADATA_KEY },
+        });
+    }
+    async upsertInstanceId(instanceId) {
+        return await this.metadataService.updateOne({ where: { name: INSTANCE_ID_METADATA_KEY } }, { name: INSTANCE_ID_METADATA_KEY, value: instanceId });
+    }
+    normalizeLicenseKey(value) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalized = value.trim();
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    disableAllFeatures() {
+        license_feature_enum_1.ALL_LICENSE_FEATURES.forEach((feature) => this.features.set(feature, false));
+    }
+    syncFeatureState() {
+        if (this.status !== 'active') {
+            this.disableAllFeatures();
+            return;
+        }
+        license_feature_enum_1.ALL_LICENSE_FEATURES.forEach((feature) => {
+            const minPlan = license_feature_enum_1.FEATURE_MIN_PLAN[feature];
+            this.features.set(feature, this.planSatisfies(this.plan, minPlan));
+        });
+    }
+    planSatisfies(current, minimum) {
+        return license_feature_enum_1.LICENSE_PLAN_RANK[current] >= license_feature_enum_1.LICENSE_PLAN_RANK[minimum];
+    }
+    hasAvailableActivationSlot(licenseKey) {
+        const limit = licenseKey.activation_limit ?? 0;
+        const usage = licenseKey.activation_usage ?? 0;
+        if (limit <= 0) {
+            return true;
+        }
+        return usage < limit;
+    }
+    async applyActivatedState(response, source) {
+        const instanceId = this.normalizeLicenseKey(response.instance?.id);
+        if (instanceId) {
+            await this.upsertInstanceId(instanceId);
+        }
+        else {
+            this.logger.warn('Lemon Squeezy response has no instance id while activating license');
+        }
+        this.status = 'active';
+        this.updateUsageAndPlan(response, response.meta ?? null);
+        this.clearError();
+        this.syncFeatureState();
+        this.logger.verbose(`License active (source=${source}, plan=${this.plan}, usage=${this.activationUsage ?? 'n/a'}/${this.activationLimit ?? 'n/a'}).`);
+    }
+    updateUsageAndPlan(response, meta) {
+        this.activationLimit = response.license_key?.activation_limit ?? null;
+        this.activationUsage = response.license_key?.activation_usage ?? null;
+        this.plan = this.inferPlan(meta);
+    }
+    applyInactiveState(status = 'inactive', plan = 'unknown', reason) {
+        this.status = status;
+        this.plan = plan;
+        this.activationLimit = null;
+        this.activationUsage = null;
+        this.syncFeatureState();
+        if (reason) {
+            this.setError(reason);
+        }
+        else {
+            this.clearError();
+        }
+    }
+    clearError() {
+        this.lastError = null;
+    }
+    setError(message) {
+        this.lastError = message;
+        this.logger.warn(message);
+    }
+    inferPlan(meta) {
+        const name = meta?.product_name?.toLowerCase();
+        if (name?.includes('starter')) {
+            return 'starter';
+        }
+        if (name?.includes('pro')) {
+            return 'pro';
+        }
+        if (name?.includes('unlimited')) {
+            return 'unlimited';
+        }
+        return 'unknown';
+    }
+};
+exports.LicenseService = LicenseService;
+__decorate([
+    (0, event_emitter_1.OnEvent)('hook:setting:preUpdate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], LicenseService.prototype, "handleLicenseKeyUpdate", null);
+exports.LicenseService = LicenseService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(4, (0, typeorm_1.InjectDataSource)()),
+    __metadata("design:paramtypes", [lemon_squeezy_service_1.LemonSqueezyService,
+        setting_service_1.SettingService,
+        metadata_service_1.MetadataService,
+        logger_service_1.LoggerService,
+        typeorm_2.DataSource])
+], LicenseService);
+//# sourceMappingURL=license.service.js.map