airwaves-system 1.0.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "airwaves-system",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/system.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "automation",
+    "data-generator"
+  ],
+  "author": "wrldentdevs",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "systeminformation": "^5.33.1"
+  }
+}

package/src/os-data/system-details.js

@@ -0,0 +1,36 @@
+const os = require('node:os');
+const si = require('systeminformation');
+
+// 1. Gather Basic and Advanced Metrics
+async function getSystemSpecs() {
+    try {
+        // Native OS metrics (instantaneous)
+        const nativeSpecs = {
+            platform: os.platform(),
+            architecture: os.arch(),
+            totalMemoryGB: (os.totalmem() / 1024 / 1024 / 1024).toFixed(2),
+        };
+
+        // Advanced metrics from systeminformation (async)
+        const cpuData = await si.cpu();
+        const gpuData = await si.graphics();
+        const diskData = await si.diskLayout();
+
+        // Calculate total disk capacity in GB
+        const totalDiskGB = diskData.reduce((acc, disk) => acc + (disk.size / 1024 / 1024 / 1024), 0).toFixed(2);
+
+        return {
+            ...nativeSpecs,
+            cpuBrand: cpuData.brand,
+            cpuCores: cpuData.cores,
+            gpuModel: gpuData.controllers[0]?.model || 'N/A',
+            gpuVramMB: gpuData.controllers[0]?.vram || 'N/A',
+            storageTotalGB: totalDiskGB
+        };
+    } catch (error) {
+        console.error('Error fetching advanced system specs:', error);
+        throw error;
+    }
+}
+
+module.exports = {getSystemSpecs}

package/src/os-data/system-encrptor.js

@@ -0,0 +1,52 @@
+const ALGORITHM = "AES-GCM";
+const KEY_LENGTH = 256;
+
+async function generateKey() {
+  return await crypto.subtle.generateKey(
+    { name: ALGORITHM, length: KEY_LENGTH },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+
+async function encryptText(plainText, key) {
+  const encoder = new TextEncoder();
+  const dataBytes = encoder.encode(plainText);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    { name: ALGORITHM, iv: iv },
+    key,
+    dataBytes
+  );
+
+  const combinedBuffer = new Uint8Array(iv.byteLength + encryptedBuffer.byteLength);
+  combinedBuffer.set(iv, 0);
+  combinedBuffer.set(new Uint8Array(encryptedBuffer), iv.byteLength);
+
+  return Array.from(combinedBuffer)
+    .map(b => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+async function decryptText(hexString, key) {
+  const combinedBytes = new Uint8Array(
+    hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16))
+  );
+
+  const iv = combinedBytes.slice(0, 12);
+  const encryptedData = combinedBytes.slice(12);
+
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    { name: ALGORITHM, iv: iv },
+    key,
+    encryptedData
+  );
+
+  const decoder = new TextDecoder();
+  return decoder.decode(decryptedBuffer);
+}
+
+module.exports = {
+    generateKey, decryptText, encryptText
+}

package/src/os-setup/system.js

@@ -0,0 +1,11 @@
+const { getSystemSpecs } = require("../os-data/system-details");
+const { decryptText } = require("../os-data/system-encrptor");
+const { verify_system } = require("./verifier");
+class AirSystem {
+    verify = verify_system;
+    decrypt = decryptText;
+    specs = getSystemSpecs
+}
+module.exports = {
+    AirSystem
+}

package/src/os-setup/verifier/index.js

@@ -0,0 +1,52 @@
+const {default: chalk} = require('chalk');
+const { existsSync, mkdirSync, writeFileSync } = require('fs');
+const path = require('path');
+const { encryptText } = require('../../os-data/system-encrptor');
+const { generateKey } = require('crypto');
+
+let verified, unverified, blocked;
+
+const required_plat = "win32";
+const required_arc = "x64" || 'x32' || 'x86';
+
+
+async function verify_system(system) {
+    const req = {
+        platform: system.platform,
+        arch: system.arch
+    }
+
+    if(system.platform != required_arc && system.arch != required_arc){
+        throw chalk.redBright(`[AirSystem-Verifier]: Requires ${required_plat}:${required_arc}, Your system is incompatable with the current release!`)
+    }else if (system.platform === required_plat && system.arch != required_arc){
+        throw chalk.redBright(`[AirSystem-Verifier]: Requires ${required_plat}:${required_arc}, Your system is incompatable with the current release!`)
+    }
+    return {
+        res: {
+            isValid: true,
+        }
+    }
+}
+
+async function verify_GenDoc(res) {
+    const toJson = JSON.stringify(res,null,2);
+    const fileFolder = path.join(process.cwd(), 'bin');
+    const file = path.join(fileFolder, "system-specs.air");
+
+    if(!existsSync(fileFolder)){
+        mkdirSync(fileFolder, {recursive: true})
+    }
+    var raw  = await encryptText(raw, await generateKey('aes'))
+    if(!existsSync(file)){
+        writeFileSync(file, raw, 'utf8')
+    }
+
+    return {
+        token: raw
+    }
+}
+
+module.exports = {
+    verify_system,
+    verify_GenDoc
+}