@mostajs/licensing-ui-react 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# @mostajs/licensing-ui-react
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+
+UI de **gestion de licences** (gate d'accès, activation, configuration) — **extraite de
+`SolutionCh/MostaGare`** et **composant `@mostajs/licensing`** (DEVRULES §10 : aucune logique de
+licence réécrite). **Config pilotée par `.env`.**
+
+```ts
+import { createLicenseUiFromEnv, LicenseGate, LicenseActivationForm } from '@mostajs/licensing-ui-react';
+
+// Contrôleur configuré depuis .env (LICENSE_SERVER_URL / LICENSE_PROJECT / LICENSE_PUBLIC_KEY)
+const lic = createLicenseUiFromEnv(process.env);
+lic.check(signedLicense);                                  // vérif RSA + projet + expiration
+lic.requestCode({ email });                                // demande un code d'activation
+lic.activate({ activationCode, machineId });               // download + verify + notify
+
+// Composants React (Next/React) — gate d'accès
+<LicenseGate project="salsabil"><App/></LicenseGate>
+```
+
+## Membres / config
+Stack : `mosta-licensing-stack`. Pair logique : `@mostajs/licensing`.
+Variables `.env` : `LICENSE_SERVER_URL` (défaut `https://licences.amia.fr`), `LICENSE_PROJECT`,
+`LICENSE_PUBLIC_KEY` (PEM base64).
+
+## Provenance
+Composants extraits : `LicenseGate`, `EnhancedLicenseGate`, `LicenseActivationForm`,
+`SimpleLicenseActivation`, `PendingLicenseActivation`, `LicenseConfigForm` + `lib/license-service`,
+`lib/licenseClient`. **À généraliser** : remplacer les URLs/projets codés en dur par
+`createLicenseUiFromEnv`. Fiche LLM : `llms.txt`.

package/llms.txt

@@ -0,0 +1,43 @@
+# @mostajs/licensing-ui-react — fiche LLM
+> UI de licence (gate d'accès, activation, configuration) — extraite de MostaGare, compose @mostajs/licensing.
+
+- Version: 0.1.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
+- Stack: mosta-licensing-stack · Pair logique: @mostajs/licensing
+
+## RÔLE
+Couche de PRÉSENTATION des licences. Composants React EXTRAITS de SolutionCh/MostaGare
+(LicenseGate, EnhancedLicenseGate, LicenseActivationForm, SimpleLicenseActivation,
+PendingLicenseActivation, LicenseConfigForm) + un contrôleur HEADLESS qui COMPOSE
+@mostajs/licensing (DEVRULES §10 : aucune logique de licence réécrite).
+
+## EXPORTS
+- LicenseProvider, useLicenseUi   ← contexte alimenté par createLicenseUiFromEnv (config .env)
+- Composants React (GÉNÉRALISÉS : consomment useLicenseUi, plus d'URL/projet en dur) :
+  LicenseGate, EnhancedLicenseGate, LicenseActivationForm, SimpleLicenseActivation,
+  PendingLicenseActivation, LicenseConfigForm  (./react/*)
+- createLicenseUi(opts) -> { client, check, requestCode, activate }
+- createLicenseUiFromEnv(env) / licenseUiConfigFromEnv(env)   ← CONFIG PILOTÉE PAR .env
+
+## USAGE REACT
+Entourer l'app de <LicenseProvider env={{ LICENSE_SERVER_URL, LICENSE_PROJECT, LICENSE_PUBLIC_KEY }}>
+puis utiliser <LicenseGate>/<LicenseActivationForm> (qui lisent serverUrl/project via useLicenseUi()).
+
+## CONFIG .env
+- LICENSE_SERVER_URL  (défaut https://licences.amia.fr)
+- LICENSE_PROJECT     (ex. salsabil)
+- LICENSE_PUBLIC_KEY  (clé publique PEM, base64)
+
+## API (contrôleur headless, compose @mostajs/licensing)
+- check(signed) -> { valid, status, reason?, expiresAt }      (checkLicense)
+- requestCode({ email, company?, message? })                  (POST /api/request-activation-code)
+- activate({ activationCode, machineId, machineName? })        (download + verify + notify)
+- client : le createLicenseClient brut de @mostajs/licensing
+
+## DÉPEND DE (peer)
+- @mostajs/licensing (logique : checkLicense, createLicenseClient), react, lucide-react
+
+## NOTE EXTRACTION
+Composants extraits de MostaGare (`src/components/license/*`, `lib/license-service`, `lib/licenseClient`)
+PUIS GÉNÉRALISÉS : URLs serveur & projet codés en dur remplacés par la config .env — les composants
+React lisent serverUrl/project via useLicenseUi() (<LicenseProvider> ← createLicenseUiFromEnv) ; les
+libs lisent process.env.LICENSE_SERVER_URL / LICENSE_PROJECT (avec repli). Plus aucun 'MostaGare'/'gestigare'.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mostajs/licensing-ui-react",
+  "version": "0.1.0",
+  "description": "UI de licence (gate d'accès, activation, configuration) — extraite de MostaGare, compose @mostajs/licensing (vérif RSA + client serveur de licences).",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./react/*": "./src/react/*"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "llms.txt"
+  ],
+  "keywords": [
+    "license",
+    "licence",
+    "activation",
+    "ui",
+    "react",
+    "mostajs"
+  ],
+  "peerDependencies": {
+    "@mostajs/licensing": ">=0.1.0",
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "lucide-react": ">=0.300.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+// @mostajs/licensing-ui — couche de PRÉSENTATION des licences.
+// Composants React EXTRAITS de SolutionCh/MostaGare (gate, activation, configuration) +
+// contrôleur headless qui COMPOSE @mostajs/licensing (client serveur + vérif RSA). DEVRULES §10.
+// @author Dr Hamid MADANI <drmdh@msn.com>
+
+// Contexte de configuration (.env) — les composants le consomment via useLicenseUi().
+export { LicenseProvider, useLicenseUi } from './react/LicenseProvider';
+
+// Composants React (extraits de MostaGare) — réutilisables par les apps Next/React.
+export { default as LicenseGate } from './react/LicenseGate';
+export { default as EnhancedLicenseGate } from './react/EnhancedLicenseGate';
+export { default as LicenseActivationForm } from './react/LicenseActivationForm';
+export { default as SimpleLicenseActivation } from './react/SimpleLicenseActivation';
+export { default as PendingLicenseActivation } from './react/PendingLicenseActivation';
+export { default as LicenseConfigForm } from './react/LicenseConfigForm';
+
+import { createLicenseClient, checkLicense } from '@mostajs/licensing';
+
+export interface LicenseUiOptions {
+  /** URL du serveur de licences (ex. https://licences.amia.fr). */
+  baseUrl: string;
+  /** Projet (ex. 'salsabil', 'MostaGare'). */
+  project?: string;
+  /** Clé publique PEM pour vérifier les signatures. */
+  publicKeyPem?: string;
+  /** fetch injectable (défaut: global). */
+  fetch?: any;
+}
+
+/**
+ * Contrôleur headless — COMPOSE @mostajs/licensing (pas de logique réécrite) :
+ * client du serveur de licences + vérification de signature/expiration. Les composants
+ * React s'y branchent (un seul point d'intégration, testable sans navigateur).
+ */
+/**
+ * Construit les options depuis l'environnement (.env) — CONFIG PILOTÉE PAR .env :
+ *   LICENSE_SERVER_URL  (défaut https://licences.amia.fr)
+ *   LICENSE_PROJECT     (ex. salsabil)
+ *   LICENSE_PUBLIC_KEY  (clé publique PEM en base64)
+ */
+export function licenseUiConfigFromEnv(env: Record<string, string | undefined> = {}): LicenseUiOptions {
+  return {
+    baseUrl: env.LICENSE_SERVER_URL || 'https://licences.amia.fr',
+    project: env.LICENSE_PROJECT || undefined,
+    publicKeyPem: env.LICENSE_PUBLIC_KEY ? Buffer.from(env.LICENSE_PUBLIC_KEY, 'base64').toString('utf8') : undefined,
+  };
+}
+
+/** Raccourci : contrôleur configuré entièrement depuis .env. */
+export function createLicenseUiFromEnv(env: Record<string, string | undefined> = {}) {
+  return createLicenseUi(licenseUiConfigFromEnv(env));
+}
+
+export function createLicenseUi(opts: LicenseUiOptions) {
+  const client = createLicenseClient({ baseUrl: opts.baseUrl, publicKeyPem: opts.publicKeyPem, fetch: opts.fetch });
+  return {
+    client,
+    /** Vérifie une licence signée (signature RSA + projet + expiration). */
+    check: (signed: any) => checkLicense(signed, { project: opts.project, publicKeyPem: opts.publicKeyPem ?? '' }),
+    /** Demande un code d'activation par email. */
+    requestCode: (p: { email: string; company?: string; message?: string }) =>
+      client.requestActivationCode({ project: opts.project ?? '', ...p }),
+    /** Active une machine : télécharge la licence du code, la vérifie, notifie. */
+    activate: (p: { activationCode: string; machineId: string; machineName?: string }) =>
+      client.activate({ project: opts.project, ...p }),
+  };
+}

package/src/lib/license-service.ts

@@ -0,0 +1,360 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import os from "os";
+
+export interface LicenseInfo {
+  key: string;
+  email: string;
+  project: string;
+  expires_at: string;
+  activations: Activation[];
+  max_activations: number;
+}
+
+export interface Activation {
+  machine_id: string;
+  machine_name: string;
+  activated_at: string;
+}
+
+export interface LicenseStatus {
+  valid: boolean;
+  status: 'valid' | 'invalid' | 'expired' | 'error';
+  reason?: string;
+  message?: string;
+  license?: LicenseInfo;
+  remaining_days?: number;
+  remaining_activations?: number;
+}
+
+export class LicenseService {
+  private licenseDir: string;
+  private publicKeyPath: string;
+  private licensePath: string | null = null;
+
+  constructor() {
+    this.licenseDir = path.join(process.cwd(), "licences");
+    this.publicKeyPath = path.join(this.licenseDir, "public.pem");
+    this.findLicenseFile();
+  }
+
+  /**
+   * Trouve le fichier de licence signé
+   */
+  private findLicenseFile(): void {
+    if (fs.existsSync(this.licenseDir)) {
+      const files = fs.readdirSync(this.licenseDir);
+      const licenseFile = files.find(file => file.endsWith('_licence.signed.json'));
+      
+      if (licenseFile) {
+        this.licensePath = path.join(this.licenseDir, licenseFile);
+      }
+    }
+  }
+
+  /**
+   * Obtient l'ID unique de la machine
+   */
+  public getMachineId(): string {
+    const networkInterfaces = os.networkInterfaces();
+    const macAddresses: string[] = [];
+    
+    for (const interfaceName in networkInterfaces) {
+      const interfaces = networkInterfaces[interfaceName];
+      if (interfaces) {
+        for (const iface of interfaces) {
+          if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
+            macAddresses.push(iface.mac);
+          }
+        }
+      }
+    }
+    
+    // Utiliser la première adresse MAC ou un ID basé sur le hostname
+    const machineId = macAddresses.length > 0 
+      ? macAddresses[0].replace(/:/g, '').toUpperCase()
+      : crypto.createHash('sha256').update(os.hostname()).digest('hex').substring(0, 12).toUpperCase();
+    
+    return machineId;
+  }
+
+  /**
+   * Obtient le nom de la machine
+   */
+  public getMachineName(): string {
+    return os.hostname();
+  }
+
+  /**
+   * Vérifie la signature de la licence
+   */
+  private verifySignature(signedData: any, publicKey: string): boolean {
+    try {
+      // Vérification temporaire pour les signatures du serveur web
+      // Détection générique basée sur le format du code d'activation
+      const isWebServerLicense = signedData.license.key && 
+        /^[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}$/.test(signedData.license.key);
+      
+      if (isWebServerLicense) {
+        console.log("Code généré par serveur web détecté (format XXXX-XXXX-XXXX-XXXX), validation RSA appliquée");
+        // Continuer avec la vérification RSA normale pour les codes du serveur web
+      } else if (signedData.signature && signedData.signature.includes(signedData.license.project)) {
+        console.log("Signature temporaire détectée, validation bypassed pour développement");
+        return true;
+      }
+      
+      // Si la licence a des activations, vérifier sans les activations (signature originale)
+      const licenseForVerification = { ...signedData.license };
+      if (licenseForVerification.activations && licenseForVerification.activations.length > 0) {
+        // Créer une copie sans les activations pour vérifier la signature originale
+        delete licenseForVerification.activations;
+        console.log("Licence avec activations détectée, vérification sans les activations");
+      }
+      
+      // Reconstruire le JSON canonique (comme côté Python)
+      const sortedKeys = Object.keys(licenseForVerification).sort();
+      const sortedLicense: any = {};
+      for (const key of sortedKeys) {
+        sortedLicense[key] = licenseForVerification[key];
+      }
+      
+      const canonicalPayload = JSON.stringify(sortedLicense);
+      
+      // Vérifier la signature
+      const verify = crypto.createVerify("RSA-SHA256");
+      verify.update(canonicalPayload, "utf8");
+      verify.end();
+      
+      const signatureBuffer = Buffer.from(signedData.signature, "hex");
+      return verify.verify(publicKey, signatureBuffer);
+      
+    } catch (error) {
+      console.error("Erreur vérification signature:", error);
+      return false;
+    }
+  }
+
+  /**
+   * Vérifie la licence complète
+   */
+  public async verifyLicense(): Promise<LicenseStatus> {
+    try {
+      // Vérifier l'existence des fichiers
+      if (!this.licensePath || !fs.existsSync(this.licensePath)) {
+        return {
+          valid: false,
+          status: 'invalid',
+          reason: 'license_not_found',
+          message: 'Aucun fichier de licence trouvé'
+        };
+      }
+
+      if (!fs.existsSync(this.publicKeyPath)) {
+        return {
+          valid: false,
+          status: 'invalid',
+          reason: 'public_key_not_found',
+          message: 'Clé publique non trouvée'
+        };
+      }
+
+      // Lire les fichiers
+      const signedData = JSON.parse(fs.readFileSync(this.licensePath, "utf8"));
+      const publicKey = fs.readFileSync(this.publicKeyPath, "utf8");
+
+      // Vérifier la structure
+      if (!signedData.license || !signedData.signature) {
+        return {
+          valid: false,
+          status: 'invalid',
+          reason: 'invalid_format',
+          message: 'Format de licence invalide'
+        };
+      }
+
+      // Vérifier la signature
+      if (!this.verifySignature(signedData, publicKey)) {
+        return {
+          valid: false,
+          status: 'invalid',
+          reason: 'invalid_signature',
+          message: 'Signature invalide'
+        };
+      }
+
+      // Vérifier la date d'expiration
+      const now = new Date();
+      const expiryDate = new Date(signedData.license.expires_at);
+      const timeDiff = expiryDate.getTime() - now.getTime();
+      const remainingDays = Math.ceil(timeDiff / (1000 * 3600 * 24));
+
+      if (now > expiryDate) {
+        return {
+          valid: false,
+          status: 'expired',
+          reason: 'license_expired',
+          message: `Licence expirée depuis ${-remainingDays} jours`,
+          license: signedData.license,
+          remaining_days: remainingDays
+        };
+      }
+
+      // Vérifier le nombre d'activations
+      const activations = signedData.license.activations || [];
+      const maxActivations = signedData.license.max_activations || 3;
+      
+      // Vérifier si cette machine est activée
+      const machineId = this.getMachineId();
+      const isThisMachineActivated = activations.some((a: Activation) => a.machine_id === machineId);
+      
+      if (!isThisMachineActivated && activations.length >= maxActivations) {
+        return {
+          valid: false,
+          status: 'invalid',
+          reason: 'max_activations_reached',
+          message: `Nombre maximum d'activations atteint (${maxActivations})`,
+          license: signedData.license
+        };
+      }
+
+      // Licence valide !
+      return {
+        valid: true,
+        status: 'valid',
+        message: 'Licence valide et active',
+        license: signedData.license,
+        remaining_days: remainingDays,
+        remaining_activations: maxActivations - activations.length
+      };
+
+    } catch (error: any) {
+      return {
+        valid: false,
+        status: 'error',
+        reason: 'verification_error',
+        message: error.message || 'Erreur lors de la vérification'
+      };
+    }
+  }
+
+  /**
+   * Notifie le serveur qu'une activation a eu lieu
+   */
+  private async notifyServerActivation(activationCode: string, machineId: string, machineName: string): Promise<void> {
+    try {
+      const { exec } = require('child_process');
+      const util = require('util');
+      const execPromise = util.promisify(exec);
+      
+      const curlCommand = `curl -k -X POST ${process.env.LICENSE_SERVER_URL || "https://licences.amia.fr"}/api/notify-activation \
+        -H "Content-Type: application/x-www-form-urlencoded" \
+        -d "activationCode=${activationCode}&machineId=${machineId}&machineName=${machineName}"`;
+      
+      await execPromise(curlCommand);
+      console.log("Activation notifiée au serveur avec succès");
+    } catch (error) {
+      console.warn("Erreur lors de la notification au serveur:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Active la licence pour cette machine
+   */
+  public async activateMachine(): Promise<{ success: boolean; message: string; activation?: Activation }> {
+    try {
+      if (!this.licensePath || !fs.existsSync(this.licensePath)) {
+        return {
+          success: false,
+          message: 'Licence non trouvée'
+        };
+      }
+
+      const signedData = JSON.parse(fs.readFileSync(this.licensePath, "utf8"));
+      const activations = signedData.license.activations || [];
+      const maxActivations = signedData.license.max_activations || 3;
+      
+      const machineId = this.getMachineId();
+      const machineName = this.getMachineName();
+
+      // Vérifier si déjà activée
+      const existingActivation = activations.find((a: Activation) => a.machine_id === machineId);
+      if (existingActivation) {
+        return {
+          success: true,
+          message: 'Machine déjà activée',
+          activation: existingActivation
+        };
+      }
+
+      // Vérifier la limite
+      if (activations.length >= maxActivations) {
+        return {
+          success: false,
+          message: `Limite d'activations atteinte (${maxActivations})`
+        };
+      }
+
+      // Ajouter l'activation
+      const newActivation: Activation = {
+        machine_id: machineId,
+        machine_name: machineName,
+        activated_at: new Date().toISOString()
+      };
+
+      activations.push(newActivation);
+      signedData.license.activations = activations;
+
+      // Sauvegarder (Note: invalide la signature)
+      fs.writeFileSync(this.licensePath, JSON.stringify(signedData, null, 2));
+
+      // Notifier le serveur de l'activation
+      try {
+        const activationCode = signedData.license.key;
+        if (activationCode) {
+          await this.notifyServerActivation(activationCode, machineId, machineName);
+        }
+      } catch (error) {
+        console.warn("Impossible de notifier le serveur de l'activation:", error);
+        // Ne pas faire échouer l'activation pour autant
+      }
+
+      return {
+        success: true,
+        message: 'Machine activée avec succès',
+        activation: newActivation
+      };
+
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.message || 'Erreur lors de l\'activation'
+      };
+    }
+  }
+
+  /**
+   * Obtient les informations de licence de manière sécurisée
+   */
+  public async getLicenseInfo(): Promise<LicenseInfo | null> {
+    const status = await this.verifyLicense();
+    return status.license || null;
+  }
+
+  /**
+   * Vérifie si la licence est valide et cette machine est activée
+   */
+  public async isLicenseValidAndActivated(): Promise<boolean> {
+    const status = await this.verifyLicense();
+    if (!status.valid) return false;
+
+    const machineId = this.getMachineId();
+    const activations = status.license?.activations || [];
+    
+    return activations.some(a => a.machine_id === machineId);
+  }
+}
+
+// Export une instance singleton
+export const licenseService = new LicenseService();

package/src/lib/licenseClient.ts

@@ -0,0 +1,76 @@
+import axios from "axios";
+import os from "os";
+import { hostname } from "os";
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+// Config pilotée par .env : LICENSE_SERVER_URL, LICENSE_PROJECT (avec repli paramètre).
+const SERVER_URL = (process.env.LICENSE_SERVER_URL || "https://licences.amia.fr").replace(/\/+$/, "");
+const DEFAULT_PROJECT = process.env.LICENSE_PROJECT || "app";
+
+export async function requestLicenseFromClient(email: string, project = DEFAULT_PROJECT, version = "1.0.0") {
+  const device_id = crypto.createHash("sha256")
+    .update(os.hostname() + os.platform())
+    .digest("hex");
+
+  const data = {
+    email,
+    project,
+    version,
+    device_id,
+    os_info: `${os.platform()} ${os.release()}`,
+    hostname: hostname()
+  };
+
+  try {
+    const res = await axios.post(`${SERVER_URL}/api/licenses/generate-from-client`, data, {
+      responseType: "blob"
+    });
+
+    const dir = path.join(process.cwd(), "licences");
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir);
+    const filePath = path.join(dir, `${project}_licence.signed.json`);
+    fs.writeFileSync(filePath, res.data);
+    return { success: true, filePath };
+  } catch (error: any) {
+    console.error("❌ Erreur :", error.response?.data || error.message);
+    return { success: false, error };
+  }
+}
+export async function validateLicense(licensePath: string, pubkeyPath: string) {
+  try {
+    const license = JSON.parse(fs.readFileSync(licensePath, "utf8"));
+    const pubKey = fs.readFileSync(pubkeyPath, "utf8");
+
+    const verify = crypto.createVerify("SHA256");
+    verify.update(JSON.stringify(license.license));
+    verify.end();
+
+    const isValid = verify.verify(pubKey, Buffer.from(license.signature, "hex"));
+
+    if (isValid) {
+      const now = new Date().toISOString();
+      if (now < license.license.expires_at) {
+        return { valid: true };
+      } else {
+        return { valid: false, reason: "expired" };
+      }
+    } else {
+      return { valid: false, reason: "invalid_signature" };
+    }
+  } catch (e) {
+    console.error("Erreur licence :", e);
+    return { valid: false, reason: "error", error: e };
+  }
+}
+export async function checkLicenseValidity() {
+  const licensePath = path.join(process.cwd(), "licences", `${DEFAULT_PROJECT}_licence.signed.json`);
+  const pubkeyPath = path.join(process.cwd(), "licences", "public.pem");
+
+  if (!fs.existsSync(licensePath) || !fs.existsSync(pubkeyPath)) {
+    return { valid: false, reason: "missing_files" };
+  }
+
+  return await validateLicense(licensePath, pubkeyPath);
+}