xypriss 9.0.0 → 9.0.2

package/package.json

@@ -264,7 +264,7 @@
         "build:memory": "NODE_OPTIONS='--max-old-space-size=6144' npx rollup -c rollup.config.js",
         "install-memory-cli": "node scripts/install-memory-cli.js",
         "install-xsys": "node scripts/postinstall-xsys.js",
-        "postinstall": "node scripts/postinstall-xsys.js && node scripts/install-xems.js && node scripts/postinstall.js",
+        "postinstall": "node scripts/postinstall.js",
         "prepublishOnly": "npm run build",
         "test": "jest",
         "test:coverage": "jest --coverage",
@@ -274,5 +274,6 @@
     "support": "https://github.com/Nehonix-Team/XyPriss/issues",
     "type": "module",
     "types": "dist/index.d.ts",
-    "version": "9.0.0"
+    "version": "9.0.2"
 }
+

package/scripts/install-memory-cli.js

@@ -15,9 +15,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const CDN_BASE_URL = "https://dll.nehonix.com/dl/mds/xypriss/bin";
-// Install binary in the package's own bin directory, not user's project
 const BIN_DIR = path.join(__dirname, "..", "bin");
-const TIMEOUT = 40000; // 40 seconds
+const TIMEOUT = 40000;
 
 /**
  * Get platform-specific binary information
@@ -26,124 +25,76 @@ function getPlatformBinary() {
     const platform = process.platform;
     const arch = process.arch;
 
-    let binaryName;
-    let downloadName;
-
+    let binaryTarget;
     if (platform === "win32") {
-        binaryName =
-            arch === "arm64"
-                ? "memory-cli-windows-arm64.exe"
-                : "memory-cli-windows-x64.exe";
-        downloadName = binaryName;
+        binaryTarget = arch === "arm64" ? "windows-arm64" : "windows-x64";
     } else if (platform === "darwin") {
-        binaryName =
-            arch === "arm64"
-                ? "memory-cli-darwin-arm64"
-                : "memory-cli-darwin-x64";
-        downloadName = binaryName;
+        binaryTarget = arch === "arm64" ? "darwin-arm64" : "darwin-x64";
     } else if (platform === "linux") {
-        binaryName = "memory-cli-linux-x64";
-        downloadName = binaryName;
+        binaryTarget = arch === "arm64" ? "linux-arm64" : "linux-x64";
     } else {
-        console.warn(
-            `⚠️  Unsupported platform: ${platform}-${arch}. Memory CLI will use fallback mode.`
-        );
         return null;
     }
 
+    const binaryName = `memory-cli-${binaryTarget}${platform === "win32" ? ".exe" : ""}`;
+
     return {
         binaryName,
-        downloadName,
-        url: `${CDN_BASE_URL}/${downloadName}`,
+        url: `${CDN_BASE_URL}/${binaryName}`,
         localPath: path.join(BIN_DIR, binaryName),
         genericPath: path.join(
             BIN_DIR,
-            "memory-cli" + (platform === "win32" ? ".exe" : "")
+            "memory-cli" + (platform === "win32" ? ".exe" : ""),
         ),
     };
 }
 
 /**
- * Download file from URL
+ * Download file from URL with Redirect support
  */
 function downloadFile(url, destination) {
     return new Promise((resolve, reject) => {
-        console.log(`📥 Downloading ${url}...`);
-
         const file = fs.createWriteStream(destination);
         const request = https.get(url, { timeout: TIMEOUT }, (response) => {
+            if (
+                response.statusCode >= 300 &&
+                response.statusCode < 400 &&
+                response.headers.location
+            ) {
+                file.close();
+                fs.unlinkSync(destination);
+                return downloadFile(response.headers.location, destination)
+                    .then(resolve)
+                    .catch(reject);
+            }
+
             if (response.statusCode === 200) {
                 response.pipe(file);
-
                 file.on("finish", () => {
                     file.close();
-                    console.log(`✅ Downloaded to ${destination}`);
                     resolve();
                 });
-            } else if (
-                response.statusCode === 302 ||
-                response.statusCode === 301
-            ) {
-                // Handle redirects
-                file.close();
-                fs.unlinkSync(destination);
-                downloadFile(response.headers.location, destination)
-                    .then(resolve)
-                    .catch(reject);
             } else {
                 file.close();
                 fs.unlinkSync(destination);
-                reject(
-                    new Error(
-                        `HTTP ${response.statusCode}: ${response.statusMessage}`
-                    )
-                );
+                reject(new Error(`HTTP ${response.statusCode}`));
             }
         });
 
         request.on("error", (error) => {
             file.close();
-            if (fs.existsSync(destination)) {
-                fs.unlinkSync(destination);
-            }
+            if (fs.existsSync(destination)) fs.unlinkSync(destination);
             reject(error);
         });
-
-        request.on("timeout", () => {
-            request.destroy();
-            file.close();
-            if (fs.existsSync(destination)) {
-                fs.unlinkSync(destination);
-            }
-            reject(new Error("Download timeout"));
-        });
     });
 }
 
-/**
- * Make file executable (Unix-like systems)
- */
-function makeExecutable(filePath) {
-    if (process.platform !== "win32") {
-        try {
-            execSync(`chmod +x "${filePath}"`);
-            console.log(`🔧 Made ${filePath} executable`);
-        } catch (error) {
-            console.warn(
-                `⚠️  Failed to make ${filePath} executable:`,
-                error.message
-            );
-        }
-    }
-}
-
 /**
  * Verify downloaded binary works
  */
 function verifyBinary(filePath) {
     return new Promise((resolve) => {
         try {
-            // spawn is already imported at the top
             const child = spawn(filePath, ["--help"], {
                 stdio: "pipe",
                 timeout: 5000,
@@ -156,140 +107,74 @@ function verifyBinary(filePath) {
 
             child.on("close", (code) => {
                 if (code === 0 && output.includes("XyPriss Memory Info CLI")) {
-                    console.log(`✅ Binary verification successful`);
                     resolve(true);
                 } else {
-                    console.warn(
-                        `⚠️  Binary verification failed (exit code: ${code})`
-                    );
                     resolve(false);
                 }
             });
 
-            child.on("error", () => {
-                resolve(false);
-            });
+            child.on("error", () => resolve(false));
         } catch (error) {
             resolve(false);
         }
     });
 }
 
-/**
- * Main installation function
- */
 async function installMemoryCLI() {
-    console.log("🚀 Installing XyPriss Memory CLI...");
-
-    // Create bin directory if it doesn't exist
     if (!fs.existsSync(BIN_DIR)) {
         fs.mkdirSync(BIN_DIR, { recursive: true });
-        console.log(`📁 Created bin directory: ${BIN_DIR}`);
     }
 
-    const binaryInfo = getPlatformBinary();
-    if (!binaryInfo) {
+    const info = getPlatformBinary();
+    if (!info) return;
+
+    console.log(`📂 Target directory: ${BIN_DIR}`);
+    console.log(`📦 Binary: ${info.binaryName}`);
+
+    if (fs.existsSync(info.genericPath)) {
         console.log(
-            "⚠️  No binary available for this platform. Using fallback mode."
+            `✨ Memory CLI already present at ${info.genericPath}, skipping.`,
         );
         return;
     }
 
     try {
-        // First, try to copy from development bin if it exists (for development/testing)
-        const devBinaryPath = path.join(
-            __dirname,
-            "..",
-            "bin",
-            binaryInfo.downloadName
-        );
-        if (fs.existsSync(devBinaryPath)) {
-            console.log(
-                `📋 Copying binary from development location: ${devBinaryPath}`
-            );
-            fs.copyFileSync(devBinaryPath, binaryInfo.localPath);
-        } else {
-            // Download the binary from CDN
-            await downloadFile(binaryInfo.url, binaryInfo.localPath);
+        console.log(`📥 Fetching Memory CLI from: ${info.url}`);
+        await downloadFile(info.url, info.localPath);
+
+        if (process.platform !== "win32") {
+            fs.chmodSync(info.localPath, 0o755);
         }
 
-        // Make it executable
-        makeExecutable(binaryInfo.localPath);
+        if (process.platform === "win32") {
+            fs.copyFileSync(info.localPath, info.genericPath);
+        } else {
+            if (fs.existsSync(info.genericPath))
+                fs.unlinkSync(info.genericPath);
+            fs.symlinkSync(path.basename(info.localPath), info.genericPath);
+        }
 
-        // Create a generic symlink/copy for easier access
-        if (!fs.existsSync(binaryInfo.genericPath)) {
-            if (process.platform === "win32") {
-                // On Windows, copy the file
-                fs.copyFileSync(binaryInfo.localPath, binaryInfo.genericPath);
-            } else {
-                // On Unix-like systems, create a symlink
-                fs.symlinkSync(
-                    path.basename(binaryInfo.localPath),
-                    binaryInfo.genericPath
-                );
-            }
+        const isValid = await verifyBinary(info.localPath);
+        if (isValid) {
             console.log(
-                `🔗 Created generic binary link: ${binaryInfo.genericPath}`
+                `🎉 XyPriss MCLI installed successfully at: ${info.genericPath}`,
             );
-        }
-
-        // Verify the binary works
-        const isValid = await verifyBinary(binaryInfo.localPath);
-        if (!isValid) {
+        } else {
             console.warn(
-                "⚠️  Binary verification failed. Memory CLI will use fallback mode."
+                "⚠️  MCLI verification failed, it might not work as expected.",
             );
-            return;
         }
-
-        console.log("🎉 XyPriss MCLI installed successfully!");
     } catch (error) {
         console.error("❌ Failed to install Memory CLI:", error.message);
-        console.log("Memory CLI will use fallback mode (Node.js os module)");
-
-        // Clean up partial downloads
-        if (fs.existsSync(binaryInfo.localPath)) {
-            try {
-                fs.unlinkSync(binaryInfo.localPath);
-            } catch (cleanupError) {
-                // Ignore cleanup errors
-            }
-        }
-    }
-}
-
-/**
- * Check if we should skip installation
- */
-function shouldSkipInstall() {
-    // Skip if CI environment variable is set to avoid network calls in CI
-    if (
-        process.env.CI === "true" ||
-        process.env.SKIP_BINARY_DOWNLOAD === "true"
-    ) {
-        console.log("Skipping binary download (CI environment detected)");
-        return true;
-    }
-
-    // Remove if binary already exists and is valid
-    const binaryInfo = getPlatformBinary();
-    if (binaryInfo && fs.existsSync(binaryInfo.localPath)) {
-        const unLinkPath = path.dirname(binaryInfo.localPath);
-        console.log("Removing MCLI dir to download latest version...");
-        fs.rmdirSync(unLinkPath, { recursive: true });
     }
-
-    return false;
 }
 
-// Run installation if this script is executed directly
+// Only run if this is the main module (not being imported)
 if (import.meta.url === `file://${process.argv[1]}`) {
-    if (!shouldSkipInstall()) {
-        installMemoryCLI().catch((error) => {
-            console.error("💥 Installation failed:", error);
-            process.exit(0); // Don't fail npm install if binary download fails
-        });
-    }
+    installMemoryCLI().catch((error) => {
+        console.error("💥 Installation failed:", error);
+        process.exit(0);
+    });
 }
 
 export { installMemoryCLI, getPlatformBinary, downloadFile, verifyBinary };

package/scripts/install-xems.js

@@ -2,10 +2,10 @@
 
 /**
  * XEMS Installer Script
- * Downloads or builds the XEMS (XyPriss Entry Management System) binary.
+ * Downloads the XEMS (XyPriss Entry Management System) binary from GitHub Releases.
+ * Supports cross-platform: Windows, Linux, and macOS (Intel & Silicon).
  */
 
-import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -15,33 +15,35 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const BIN_DIR = path.join(__dirname, "..", "bin");
-const XEMS_REPO = "https://github.com/Nehonix-Team/XyPriss-XEMS";
+const REPO = "Nehonix-Team/XyPriss-XEMS";
 const CDN_BASE_URL = "https://dll.nehonix.com/dl/mds/xems/bin"; // Fallback CDN
 
 /**
  * Get platform-specific binary information for XEMS
+ * Maps directly to the files in tools/XEMS/dist/
  */
 function getPlatformBinary() {
     const platform = process.platform;
     const arch = process.arch;
 
-    let binaryName;
+    let binaryTarget;
     if (platform === "win32") {
-        binaryName =
-            arch === "arm64"
-                ? "xems-windows-arm64.exe"
-                : "xems-windows-x64.exe";
+        binaryTarget = arch === "arm64" ? "windows-arm64" : "windows-x64";
     } else if (platform === "darwin") {
-        binaryName = arch === "arm64" ? "xems-darwin-arm64" : "xems-darwin-x64";
+        binaryTarget = arch === "arm64" ? "darwin-arm64" : "darwin-x64";
     } else if (platform === "linux") {
-        binaryName = arch === "arm64" ? "xems-linux-arm64" : "xems-linux-x64";
+        binaryTarget = arch === "arm64" ? "linux-arm64" : "linux-x64";
     } else {
         return null;
     }
 
+    // Naming convention: xems-linux-x64, xems-windows-x64.exe, etc.
+    const binaryName = `xems-${binaryTarget}${platform === "win32" ? ".exe" : ""}`;
+
     return {
         binaryName,
-        url: `${CDN_BASE_URL}/${binaryName}`,
+        url: `https://github.com/${REPO}/releases/latest/download/${binaryName}`,
+        fallbackUrl: `${CDN_BASE_URL}/${binaryName}`,
         localPath: path.join(BIN_DIR, binaryName),
         genericPath: path.join(
             BIN_DIR,
@@ -50,50 +52,118 @@ function getPlatformBinary() {
     };
 }
 
-async function installXems() {
-    console.log("🚀 Installing XEMS binary...");
+/**
+ * Download a file with redirect support
+ */
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+
+        const request = https.get(
+            url,
+            {
+                headers: { "User-Agent": "XyPriss-Installer" },
+            },
+            (response) => {
+                if (
+                    response.statusCode >= 300 &&
+                    response.statusCode < 400 &&
+                    response.headers.location
+                ) {
+                    file.close();
+                    fs.unlinkSync(dest);
+                    return downloadFile(response.headers.location, dest)
+                        .then(resolve)
+                        .catch(reject);
+                }
+
+                if (response.statusCode !== 200) {
+                    file.close();
+                    fs.unlinkSync(dest);
+                    return reject(
+                        new Error(
+                            `Server responded with ${response.statusCode}`,
+                        ),
+                    );
+                }
+
+                response.pipe(file);
+
+                file.on("finish", () => {
+                    file.close();
+                    resolve();
+                });
+            },
+        );
+
+        request.on("error", (err) => {
+            file.close();
+            if (fs.existsSync(dest)) fs.unlinkSync(dest);
+            reject(err);
+        });
+    });
+}
 
+async function installXems() {
     if (!fs.existsSync(BIN_DIR)) {
         fs.mkdirSync(BIN_DIR, { recursive: true });
     }
 
-    // Strategy 1: Build from source if local source exists (Development)
-    const localSource = path.join(__dirname, "..", "tools", "XEMS");
-    if (fs.existsSync(localSource)) {
-        console.log("🔨 Local source detected. Building XEMS from source...");
-        try {
-            const buildCmd =
-                process.platform === "win32"
-                    ? `cd "${localSource}" && go build -o "../../bin/xems.exe" ./cmd/xems/main.go`
-                    : `cd "${localSource}" && go build -o "../../bin/xems" ./cmd/xems/main.go`;
-
-            execSync(buildCmd, { stdio: "inherit" });
-            console.log("✅ XEMS built successfully from local source.");
-            return;
-        } catch (err) {
-            console.warn(
-                "⚠️ Failed to build XEMS from local source, trying other methods...",
-            );
-        }
+    const info = getPlatformBinary();
+    if (!info) {
+        console.error(
+            "❌ XEMS is not supported on this platform/architecture.",
+        );
+        return;
     }
 
-    // Strategy 2: Download from GitHub Releases / CDN (Production)
-    const info = getPlatformBinary();
-    if (info) {
+    console.log(`📂 Target directory: ${BIN_DIR}`);
+    console.log(`📦 Binary: ${info.binaryName}`);
+
+    if (fs.existsSync(info.genericPath)) {
         console.log(
-            `🌐 Downloading pre-built binary for ${process.platform}-${process.arch}...`,
+            `✨ XEMS binary already present at ${info.genericPath}, skipping.`,
         );
-        // Note: For now we'll just log and suggest building.
-        // Real implementation would use https.get to download as in install-memory-cli.js
-        // console.warn(
-        //     "⚠️ Binary download not yet implemented for the new repo. Please ensure 'go' is installed and build from source.",
-        // );
+        return;
+    }
+
+    console.log(`🌐 Downloading XEMS (${info.binaryName})...`);
+
+    try {
+        try {
+            console.log(`🌐 Downloading XEMS from GitHub: ${info.url}`);
+            await downloadFile(info.url, info.localPath);
+            console.log("✅ Downloaded from GitHub.");
+        } catch (e) {
+            console.log(
+                `📡 GitHub download failed, trying fallback CDN: ${info.fallbackUrl}`,
+            );
+            await downloadFile(info.fallbackUrl, info.localPath);
+            console.log("✅ Downloaded from fallback CDN.");
+        }
+
+        if (process.platform !== "win32") {
+            fs.chmodSync(info.localPath, 0o755);
+        }
+
+        if (process.platform === "win32") {
+            fs.copyFileSync(info.localPath, info.genericPath);
+        } else {
+            if (fs.existsSync(info.genericPath))
+                fs.unlinkSync(info.genericPath);
+            fs.symlinkSync(path.basename(info.localPath), info.genericPath);
+        }
+
+        console.log(`🚀 XEMS successfully installed at: ${info.genericPath}`);
+    } catch (err) {
+        console.error("❌ XEMS download failed:", err.message);
     }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-    installXems().catch((err) => {
-        console.error("❌ XEMS Installation failed:", err);
+    installXems().catch((error) => {
+        console.error("🔥 Installation failed:", error.message);
+        process.exit(0);
     });
 }
 

package/scripts/postinstall-xsys.js

@@ -1,9 +1,8 @@
 import { execSync } from "child_process";
-import { existsSync, mkdirSync, createWriteStream } from "fs";
-import { join, dirname } from "path";
+import fs from "fs";
+import { join, dirname, basename } from "path";
 import { platform, arch } from "os";
 import https from "https";
-
 import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -11,102 +10,118 @@ const __dirname = dirname(__filename);
 
 const REPO = "Nehonix-Team/XyPriss";
 const BIN_NAME = "xsys";
+const BIN_DIR = join(__dirname, "..", "bin");
+
+/**
+ * Téléchargement avec support des redirections GitHub
+ */
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        const request = https.get(
+            url,
+            {
+                headers: { "User-Agent": "XyPriss-Installer" },
+            },
+            (response) => {
+                if (
+                    response.statusCode >= 300 &&
+                    response.statusCode < 400 &&
+                    response.headers.location
+                ) {
+                    file.close();
+                    fs.unlinkSync(dest);
+                    return downloadFile(response.headers.location, dest)
+                        .then(resolve)
+                        .catch(reject);
+                }
+                if (response.statusCode !== 200) {
+                    file.close();
+                    fs.unlinkSync(dest);
+                    return reject(new Error(`HTTP ${response.statusCode}`));
+                }
+                response.pipe(file);
+                file.on("finish", () => {
+                    file.close();
+                    resolve();
+                });
+            },
+        );
+        request.on("error", (err) => {
+            file.close();
+            if (fs.existsSync(dest)) fs.unlinkSync(dest);
+            reject(err);
+        });
+    });
+}
 
-async function install() {
-    const targetDir = join(__dirname, "..", "bin");
-    if (!existsSync(targetDir)) {
-        mkdirSync(targetDir, { recursive: true });
+async function installXsys() {
+    if (!fs.existsSync(BIN_DIR)) {
+        fs.mkdirSync(BIN_DIR, { recursive: true });
     }
 
     const osName = platform();
     const archName = arch();
 
+    // Mappage exact avec tes fichiers dans tools/xypriss-sys-go/dist/
     let binaryTarget = "";
     if (osName === "linux") {
         binaryTarget = archName === "arm64" ? "linux-arm64" : "linux-amd64";
     } else if (osName === "darwin") {
-        binaryTarget = archName === "arm64" ? "darwin-arm64" : "darwin-amd64";
+        binaryTarget = archName === "arm64" ? "darwin-arm64" : "darwin-amd64"; // Support macOS Intel & Silicon
     } else if (osName === "win32") {
-        binaryTarget = "windows-amd64";
+        binaryTarget = archName === "arm64" ? "windows-arm64" : "windows-amd64";
     } else {
-        console.warn(
-            `Unsupported platform/architecture: ${osName}/${archName}. Attempting to build from source...`
-        );
-        try {
-            execSync("cd tools/xypriss-sys && cargo build --release", {
-                stdio: "inherit",
-            });
-            execSync(
-                `cp tools/xypriss-sys/target/release/${BIN_NAME} bin/${BIN_NAME}`,
-                { stdio: "inherit" }
-            );
-            return;
-        } catch (e) {
-            console.error(
-                "Failed to build from source. Please ensure Rust is installed."
-            );
-            process.exit(1);
-        }
+        console.error(`❌ Plateforme non supportée : ${osName}`);
+        return;
     }
 
-    const url = `https://github.com/${REPO}/releases/latest/download/${BIN_NAME}-${binaryTarget}${
-        osName === "win32" ? ".exe" : ""
-    }`;
-    const destPath = join(
-        targetDir,
-        BIN_NAME + (osName === "win32" ? ".exe" : "")
+    const binaryFileName = `${BIN_NAME}-${binaryTarget}${osName === "win32" ? ".exe" : ""}`;
+    const url = `https://github.com/${REPO}/releases/latest/download/${binaryFileName}`;
+    const localPath = join(BIN_DIR, binaryFileName);
+    const genericPath = join(
+        BIN_DIR,
+        BIN_NAME + (osName === "win32" ? ".exe" : ""),
     );
 
-    console.log(`Downloading ${BIN_NAME} from ${url}...`);
-
-    // Note: Since this is a postinstall script, we might not have 'axios' or 'node-fetch'
-    // We'll use built-in 'https'
-
-    const download = (downloadUrl) => {
-        https
-            .get(
-                downloadUrl,
-                {
-                    headers: { "User-Agent": "XyPriss-Installer" },
-                },
-                (response) => {
-                    if (
-                        response.statusCode >= 300 &&
-                        response.statusCode < 400 &&
-                        response.headers.location
-                    ) {
-                        download(response.headers.location);
-                        return;
-                    }
-
-                    if (response.statusCode === 200) {
-                        const file = createWriteStream(destPath);
-                        response.pipe(file);
-                        file.on("finish", () => {
-                            file.close();
-                            if (osName !== "win32") {
-                                execSync(`chmod +x ${destPath}`);
-                            }
-                            console.log(
-                                `${BIN_NAME} installed successfully at ${destPath}`
-                            );
-                        });
-                    } else {
-                        console.error(
-                            `Failed to download binary: ${response.statusCode}`
-                        );
-                        process.exit(1);
-                    }
-                }
-            )
-            .on("error", (err) => {
-                console.error(`Error downloading file: ${err.message}`);
-                process.exit(1);
-            });
-    };
-
-    download(url);
+    console.log(`📂 Répertoire cible : ${BIN_DIR}`);
+    console.log(`📦 Binaire : ${binaryFileName}`);
+
+    if (fs.existsSync(genericPath)) {
+        console.log(
+            `✨ XSYS est déjà présent à ${genericPath}, installation ignorée.`,
+        );
+        return;
+    }
+
+    console.log(`🌐 Téléchargement de XSYS depuis GitHub : ${url}`);
+
+    try {
+        await downloadFile(url, localPath);
+
+        if (osName !== "win32") {
+            fs.chmodSync(localPath, 0o755);
+        }
+
+        // Création du lien/copie générique
+        if (osName === "win32") {
+            fs.copyFileSync(localPath, genericPath);
+        } else {
+            if (fs.existsSync(genericPath)) fs.unlinkSync(genericPath);
+            fs.symlinkSync(basename(localPath), genericPath);
+        }
+
+        console.log(`✅ XSYS installé avec succès : ${genericPath}`);
+    } catch (err) {
+        console.error(
+            `❌ Échec de l'acquisition du binaire XSYS : ${err.message}`,
+        );
+    }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    installXsys().catch(() => process.exit(0));
 }
 
-install().catch(console.error);
+export { installXsys };
 

package/scripts/postinstall.js

@@ -6,17 +6,27 @@
  */
 
 import { installMemoryCLI } from "./install-memory-cli.js";
+import { installXems } from "./install-xems.js";
+import { installXsys } from "./postinstall-xsys.js";
 
 async function postInstall() {
     console.log("🔧 Running XyPriss post-install setup...");
 
     try {
+        // 1. Install Memory CLI
         await installMemoryCLI();
+
+        // 2. Install XEMS (Security Core)
+        await installXems();
+
+        // 3. Install XSYS (System Core)
+        await installXsys();
+
         console.log("✅ XyPriss setup complete!");
     } catch (error) {
         console.warn(
             "⚠️  Post-install setup encountered issues:",
-            error.message
+            error.message,
         );
         console.log("📝 XyPriss will continue to work with fallback mode.");
     }
@@ -32,4 +42,3 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 }
 
 export { postInstall };
-