xynginc 1.0.95 → 1.0.97

package/dist/mods/constant.js

@@ -1,4 +1,4 @@
 import path from "path";
 export const BINARY_NAME = "xynginc";
 export const GITHUB_REPO = "Nehonix-Team/xynginc";
-export const BINARY_DIR = path.join(__dirname, "../bin");
+export const BINARY_DIR = path.resolve(__dirname, "../../bin");

package/dist/mods/downloadBinary.js

@@ -4,6 +4,7 @@ import { BINARY_NAME, BINARY_DIR, GITHUB_REPO } from "./constant";
 import { __strl__ } from "strulink";
 const fs = __sys__.fs;
 const path = __sys__.path;
+let activeDownloadPromise = null;
 /**
  * Downloads the xynginc binary from GitHub releases.
  *
@@ -11,6 +12,18 @@ const path = __sys__.path;
  * @returns The path to the downloaded binary.
  */
 export async function downloadBinary(version) {
+    if (activeDownloadPromise) {
+        return activeDownloadPromise;
+    }
+    activeDownloadPromise = doDownload(version);
+    try {
+        return await activeDownloadPromise;
+    }
+    finally {
+        activeDownloadPromise = null;
+    }
+}
+async function doDownload(version) {
     const platform = __sys__.os.platform();
     const arch = __sys__.os.arch();
     if (platform !== "linux") {
@@ -21,35 +34,80 @@ export async function downloadBinary(version) {
         ? `https://github.com/${GITHUB_REPO}/releases/latest/download/${binaryName}`
         : `https://github.com/${GITHUB_REPO}/releases/download/${version}/${binaryName}`;
     Logger.info(`[XyNginC] Downloading from: ${__strl__.createUrl(downloadUrl).hostname}`);
-    // Create bin directory
-    fs.writeIfNotExistsSync(BINARY_DIR, { recursive: true });
-    const localPath = path.join(BINARY_DIR, BINARY_NAME);
+    // Ensure bin directory exists (with fallback if root package directory is read-only)
+    let targetDir = BINARY_DIR;
+    try {
+        if (!fs.exists(targetDir)) {
+            fs.ensureDir(targetDir);
+        }
+    }
+    catch {
+        const home = __sys__.os.homeDir
+            ? __sys__.os.homeDir()
+            : (typeof process !== "undefined" && process.env.HOME) || "/tmp";
+        targetDir = path.join(home, ".xynginc", "bin");
+        fs.ensureDir(targetDir);
+    }
+    const localPath = path.join(targetDir, BINARY_NAME);
     return new Promise((resolve, reject) => {
-        function download(url) {
+        function download(url, redirectCount = 0) {
+            if (redirectCount > 5) {
+                reject(new Error("[XyNginC] Too many redirects while downloading binary"));
+                return;
+            }
             https
-                .get(url, (response) => {
+                .get(url, {
+                headers: {
+                    "User-Agent": "xynginc",
+                    Accept: "*/*",
+                },
+            }, (response) => {
                 if (response.statusCode &&
                     response.statusCode >= 300 &&
                     response.statusCode < 400 &&
                     response.headers.location) {
-                    download(response.headers.location);
+                    response.resume();
+                    download(response.headers.location, redirectCount + 1);
                     return;
                 }
                 if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download binary: HTTP ${response.statusCode}`));
+                    response.resume();
+                    reject(new Error(`Failed to download binary from ${url}: HTTP ${response.statusCode}`));
                     return;
                 }
                 const file = fs.createWriteStream(localPath);
+                file.on("error", (err) => {
+                    try {
+                        fs.rmIfExists(localPath);
+                    }
+                    catch { }
+                    reject(err);
+                });
+                response.on("error", (err) => {
+                    try {
+                        fs.rmIfExists(localPath);
+                    }
+                    catch { }
+                    reject(err);
+                });
                 response.pipe(file);
                 file.on("finish", () => {
-                    file.close(); //
-                    fs.chmod(localPath, "755"); // Make executable (octal version: 0o755)
+                    file.close();
+                    try {
+                        fs.chmod(localPath, 0o755);
+                    }
+                    catch {
+                        // Ignore chmod error if any
+                    }
                     Logger.success("[XyNginC] ✓ Binary downloaded successfully");
                     resolve(localPath);
                 });
             })
                 .on("error", (err) => {
-                fs.rmIfExists(localPath);
+                try {
+                    fs.rmIfExists(localPath);
+                }
+                catch { }
                 reject(err);
             });
         }

package/dist/mods/ensureBinary.js

@@ -30,12 +30,28 @@ export async function ensureBinary(customPath, autoDownload, version) {
     catch {
         // Not in PATH
     }
-    // 3. Try local bin directory
+    // 3. Try local bin directory (<package_root>/bin/xynginc)
     const localPath = path.join(BINARY_DIR, BINARY_NAME);
     if (fs.exists(localPath)) {
+        try {
+            fs.chmod(localPath, 0o755);
+        }
+        catch { }
         return localPath;
     }
-    // 4. Auto-download if enabled
+    // 4. Try user home cache (~/.xynginc/bin/xynginc)
+    const home = __sys__.os.homeDir
+        ? __sys__.os.homeDir()
+        : (typeof process !== "undefined" && process.env.HOME) || "/tmp";
+    const userPath = path.join(home, ".xynginc", "bin", BINARY_NAME);
+    if (fs.exists(userPath)) {
+        try {
+            fs.chmod(userPath, 0o755);
+        }
+        catch { }
+        return userPath;
+    }
+    // 5. Auto-download if enabled
     if (autoDownload) {
         Logger.info("[XyNginC] Binary not found, downloading...");
         return await downloadBinary(version);

package/dist/mods/requirements.js

@@ -13,9 +13,10 @@ export async function installRequirementsHandler(binaryPath, sudoCmd) {
         Logger.info("[XyNginC] Launching interactive installer...");
         Logger.info("[XyNginC] Please respond to any prompts in the terminal.");
         // Handle process environmental logic if running via non-interactive sudo -S
+        const envPrefix = "env XYNC_INSTALL_MODE=non-interactive DEBIAN_FRONTEND=noninteractive";
         const cmd = sudoCmd.includes("-S")
-            ? `${sudoCmd} ${binaryPath} install`
-            : `sudo ${binaryPath} install`;
+            ? `${sudoCmd} ${envPrefix} ${binaryPath} install`
+            : `sudo ${envPrefix} ${binaryPath} install`;
         // Spawn the process with inherited stdio for full interactivity
         const installProcess = spawn(cmd, {
             stdio: "inherit", // This allows the subprocess to use the parent's stdin/stdout/stderr
@@ -35,6 +36,8 @@ export async function installRequirementsHandler(binaryPath, sudoCmd) {
         });
     });
 }
+const fs = __sys__.fs;
+const path = __sys__.path;
 /**
  * Applies the configuration using the xynginc binary.
  *
@@ -52,8 +55,8 @@ export async function applyConfig(binaryPath, config, sudoCmd) {
             port: d.port,
             ssl: d.ssl,
             email: d.email,
-            host: d.host,
-            max_body_size: d.maxBodySize,
+            host: d.host || "127.0.0.1",
+            max_body_size: d.maxBodySize || "10M",
         })),
     };
     const configJson = XStringify(mappedConfig, {
@@ -63,6 +66,9 @@ export async function applyConfig(binaryPath, config, sudoCmd) {
         truncateStrings: 1000000, // 1MB limit per string (pour le HTML)
         reportCircularPath: true,
     });
+    const tmpDir = typeof fs.tempDir === "function" ? fs.tempDir() : "/tmp";
+    const tempConfigFile = path.join(tmpDir, `.xynginc-config-${Date.now()}-${Math.random().toString(36).substring(2, 8)}.json`);
+    fs.writeFileSync(tempConfigFile, configJson);
     try {
         // Test nginx BEFORE applying new config
         Logger.info("[XyNginC] Testing current nginx config...");
@@ -70,21 +76,8 @@ export async function applyConfig(binaryPath, config, sudoCmd) {
         if (!testResult) {
             Logger.warn("[XyNginC] ⚠️  Current nginx config has errors. Attempting to fix...");
         }
-        // Pass config via stdin to avoid shell escaping issues
-        // If using sudo -S, we must pass both the password and the JSON in the same pipe
-        if (sudoCmd.includes("-S")) {
-            const pwdMatch = sudoCmd.match(/echo '(.*)' \| sudo -S/);
-            if (pwdMatch) {
-                const pwd = pwdMatch[1];
-                await execStream(`(echo '${pwd}'; echo '${configJson}') | sudo -S ${binaryPath} apply --config -`);
-            }
-            else {
-                await execStream(`echo '${configJson}' | ${sudoCmd} ${binaryPath} apply --config -`);
-            }
-        }
-        else {
-            await execStream(`echo '${configJson}' | ${sudoCmd} ${binaryPath} apply --config -`);
-        }
+        // Apply configuration using the temporary file to avoid stdin collision with sudo
+        await execStream(`${sudoCmd} ${binaryPath} apply --config ${tempConfigFile}`);
     }
     catch (error) {
         // If it fails, show more helpful error
@@ -93,6 +86,12 @@ export async function applyConfig(binaryPath, config, sudoCmd) {
         Logger.info("[XyNginC] Check: /etc/nginx/sites-enabled/");
         throw new Error(`Failed to apply configuration: ${error.message}`);
     }
+    finally {
+        try {
+            fs.rmIfExists(tempConfigFile);
+        }
+        catch { }
+    }
 }
 /**
  * Adds a new domain configuration using the binary.
@@ -209,7 +208,7 @@ export async function checkRequirements(binaryPath, sudoCmd) {
     try {
         Logger.info("[XyNginC] Checking system requirements...");
         const cmd = `${sudoCmd} ${binaryPath} check`;
-        Logger.info(`[XyNginC] Running: ${cmd}`);
+        // Logger.info(`[XyNginC] Running: ${__sys__.utils.str.of(cmd).between("ech")}`);
         await execStream(cmd);
         Logger.info("[XyNginC] System requirements checked successfully!");
         return true;

package/dist/startPlugin.js

@@ -26,6 +26,8 @@ const getSudo = (sudoPassword) => {
     // Return non-interactive sudo to prevent infinite blocking/hanging
     return "sudo -n";
 };
+let appliedConfigKey = null;
+let activeInitPromise = null;
 export async function startXNCPlugin(server, options) {
     const { binaryPath, autoDownload, version, domains, autoReload, autoFixFirewall, installRequirements, sudoPassword, } = options;
     Logger.info("[XyNginC] Initializing Nginx Controller...");
@@ -42,28 +44,50 @@ export async function startXNCPlugin(server, options) {
                 binary,
             },
         });
-        // 2. Check system requirements
-        Logger.info("[XyNginC] Checking system requirements...");
-        // Check if requirements are satisfied
-        const requirementsOk = await checkRequirements(binary, getSudo(sudoPassword));
-        // Install requirements if enabled and needed
-        if (!requirementsOk && installRequirements) {
-            Logger.info("[XyNginC] Requirements missing, installing automatically...");
-            await installRequirementsHandler(binary, getSudo(sudoPassword));
-            Logger.info("[XyNginC] Requirements installed, re-checking...");
-            await checkRequirements(binary, getSudo(sudoPassword));
+        const configKey = JSON.stringify({
+            domains,
+            autoReload,
+            autoFixFirewall,
+        });
+        if (appliedConfigKey !== configKey) {
+            if (!activeInitPromise) {
+                activeInitPromise = (async () => {
+                    // 2. Check system requirements
+                    Logger.info("[XyNginC] Checking system requirements...");
+                    const requirementsOk = await checkRequirements(binary, getSudo(sudoPassword));
+                    if (!requirementsOk && installRequirements) {
+                        Logger.info("[XyNginC] Requirements missing, installing automatically...");
+                        await installRequirementsHandler(binary, getSudo(sudoPassword));
+                        Logger.info("[XyNginC] Requirements installed, re-checking...");
+                        const recheckOk = await checkRequirements(binary, getSudo(sudoPassword));
+                        if (!recheckOk) {
+                            throw new Error("[XyNginC] System requirements installation failed or was incomplete. Please run 'sudo xynginc install' manually.");
+                        }
+                    }
+                    else if (!requirementsOk) {
+                        throw new Error("[XyNginC] System requirements not satisfied. Install with 'installRequirements: true' or run: sudo xynginc install");
+                    }
+                    // 3. Apply configuration
+                    Logger.info("[XyNginC] Applying configuration...");
+                    await applyConfig(binary, {
+                        domains,
+                        auto_reload: autoReload,
+                        auto_fix_firewall: autoFixFirewall,
+                    }, getSudo(sudoPassword));
+                    appliedConfigKey = configKey;
+                    Logger.success("[XyNginC] Configuration applied successfully!");
+                })();
+            }
+            try {
+                await activeInitPromise;
+            }
+            finally {
+                activeInitPromise = null;
+            }
         }
-        else if (!requirementsOk) {
-            throw new Error("[XyNginC] System requirements not satisfied. Install with 'installRequirements: true' or run: sudo xynginc install");
+        else {
+            Logger.info("[XyNginC] Configuration already applied for this multi-server group.");
         }
-        // 3. Apply configuration
-        Logger.info("[XyNginC] Applying configuration...");
-        await applyConfig(binary, {
-            domains,
-            auto_reload: autoReload,
-            auto_fix_firewall: autoFixFirewall,
-        }, getSudo(sudoPassword));
-        Logger.success("[XyNginC] Configuration applied successfully!");
         // Expose CLI helper methods on server
         const sUtil = {
             addDomain: (domain, port, ssl = false, email, maxBodySize) => addDomain(binary, domain, port, ssl, email, maxBodySize, getSudo(sudoPassword)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xynginc",
-  "version": "1.0.95",
+  "version": "1.0.97",
   "description": "XyPriss Nginx Controller - Automatic Nginx & SSL management for XyPriss servers",
   "author": "Seth Eleazar - iDevo",
   "license": "NOSL",
@@ -48,7 +48,7 @@
     "xypriss-security": "^2.1.16"
   },
   "peerDependencies": {
-    "xypriss": ">=9.9.7"
+    "xypriss": ">=9.12.69"
   },
   "devDependencies": {
     "@types/node": "^20.19.37",

package/scripts/postinstall.js

@@ -27,32 +27,57 @@ if (!fs.existsSync(binDir)) {
   fs.mkdirSync(binDir, { recursive: true });
 }
 
-function download(url, dest) {
+function download(url, dest, redirectCount = 0) {
   return new Promise((resolve, reject) => {
+    if (redirectCount > 5) {
+      reject(new Error("Too many redirects while downloading binary"));
+      return;
+    }
+
     https
-      .get(url, (response) => {
-        if (
-          response.statusCode >= 300 &&
-          response.statusCode < 400 &&
-          response.headers.location
-        ) {
-          // Recurse for redirects
-          download(response.headers.location, dest).then(resolve).catch(reject);
-          return;
-        }
-
-        if (response.statusCode !== 200) {
-          reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
-          return;
-        }
-
-        const file = fs.createWriteStream(dest);
-        response.pipe(file);
-        file.on("finish", () => {
-          file.close();
-          resolve();
-        });
-      })
+      .get(
+        url,
+        {
+          headers: {
+            "User-Agent": "xynginc",
+            Accept: "*/*",
+          },
+        },
+        (response) => {
+          if (
+            response.statusCode >= 300 &&
+            response.statusCode < 400 &&
+            response.headers.location
+          ) {
+            response.resume();
+            download(response.headers.location, dest, redirectCount + 1)
+              .then(resolve)
+              .catch(reject);
+            return;
+          }
+
+          if (response.statusCode !== 200) {
+            response.resume();
+            reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+            return;
+          }
+
+          const file = fs.createWriteStream(dest);
+          file.on("error", (err) => {
+            fs.unlink(dest, () => {});
+            reject(err);
+          });
+          response.on("error", (err) => {
+            fs.unlink(dest, () => {});
+            reject(err);
+          });
+          response.pipe(file);
+          file.on("finish", () => {
+            file.close();
+            resolve();
+          });
+        },
+      )
       .on("error", (err) => {
         fs.unlink(dest, () => {});
         reject(err);

package/xypriss.plugin.xsig

@@ -1,11 +1,11 @@
 --- XYPRISS SIGNATURE (G3) ---
-Manifest: xynginc@1.0.95
+Manifest: xynginc@1.0.97
 Min-Engine: 1.0.81
-Fingerprint: sha256:29164ca30e93b4db58ec04a683f11e643738961ff5539561b0cbc02b0fc77216
+Fingerprint: sha256:bcb7ff347f32fadda4fb97221c8a3a345c829487b96f5b4f9917ce339d3db7c3
 Identity: ed25519:0e2e1accdbba45480979305256d50d368ae6cc2c0d7ee378c5f1999ae834cf58
 Privileges: XHS.HOOK.LIFECYCLE.REGISTER,XHS.HOOK.LIFECYCLE.SERVER_START,XHS.HOOK.LIFECYCLE.SERVER_STOP,XHS.HOOK.LIFECYCLE.SERVER_READY
-Expires: 2027-09-13T14:10:40Z
+Expires: 2027-09-13T22:23:40Z
 Revision: sha256:none
 --- BEGIN CRYPTOGRAPHIC PROOF ---
-base64:xPDNo3n8nqha9OGhhNRkMKdJxiMGy5ZddvDGcuv314t/imBXHpBjhrAM+AVWpsKEsP8gJC5jximCDzvaGFeDDg==
+base64:5GY1tW/vThkWfbexGer3o5a+/mZ9gaF+W6Iv85Odb7eH4uzU9/Vhx39WpjT4gytE0ftwsmeSxGjk/SscaDAsDw==
 --- END XYPRISS SIGNATURE ---