stack-analyze 1.1.4

package/functions/hardware.js

@@ -0,0 +1,241 @@
+// modules
+const {
+  cpu,
+  mem,
+  osInfo,
+  diskLayout,
+  graphics,
+  bios
+} = require("systeminformation");
+const { printTable } = require("console-table-printer");
+const { red } = require("colors");
+
+
+/**
+ * 
+ * @description call the async function cpuinfo
+ * @return { Promise<void> } - return cpu results
+ * 
+ */
+async function cpuInfo() {
+  try {
+    const {
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    } = await cpu();
+
+    // show results
+    console.table({
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    });
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function ram memory
+ * @return { Promise<void> } - return ram memory results
+ * 
+ */
+async function ramMemInfo() {
+  try {
+    const {
+      total,
+      free,
+      used,
+      active,
+      available
+    } = await mem();
+
+    // show results
+    console.table({
+      total_mem: `${(total / 1073741824).toFixed(2)} GB`,
+      free_mem: `${(free / 1073741824).toFixed(2)} GB`,
+      used_mem: `${(used / 1073741824).toFixed(2)} GB`,
+      active_mem: `${(active / 1073741824).toFixed(2)} GB`,
+      available_mem: `${(available / 1073741824).toFixed(2)} GB`
+    });
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function osinfo
+ * @return { Promise<void> } - return os results results
+ * 
+ */
+async function osDetail() {
+  try {
+    const {
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    } = await osInfo();
+
+    // show results
+    console.table({
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    });
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function diskinfo
+ * @return { Promise<void> } - return disks results
+ * 
+ */
+async function diskInfo() {
+  try {
+    const disks = await diskLayout();
+
+    const disksList = disks.map(({
+      type,
+      name,
+      vendor,
+      size,
+      interfaceType
+    }) => ({
+      type,
+      name,
+      vendor,
+      diskSize: `${(size / 1073741824).toFixed(2)} GB`,
+      interfaceType
+    }));
+    
+    printTable(disksList);
+
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function graphic card
+ * @return { Promise<void> } - return graphic controller results
+ * 
+ */
+async function controllerInfo() {
+  try {
+    const { controllers } = await graphics();
+
+    const controllersList = controllers.map(({
+      model,
+      vendor,
+      vram
+    }) => ({
+      model,
+      vendor,
+      vramSize: vram < 1024 
+        ? `${vram} MB`
+        : `${(vram / 1024).toFixed(2)} GB`
+    }));
+
+    // show results
+    printTable(controllersList);
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function display info
+ * @return { Promise<void> } - return display results
+ * 
+ */
+async function displayInfo() {
+  try {
+    const { displays } = await graphics();
+
+    const displayList = displays.map(({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }) => ({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }));
+
+    // show results
+    printTable(displayList);
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+/**
+ * 
+ * @description call the async function biosinfo
+ * @return { Promise<void> } - return bios info results
+ * 
+ */
+async function biosInfo() {
+  try {
+    const {
+      releaseDate,
+      vendor,
+      revision,
+      version
+    } = await bios();
+
+    console.table({
+      releaseDate,
+      vendor,
+      bios_revision: revision === "" ? "no info": revision,
+      version
+    });
+  } catch (err) {
+    console.error(red(err.message));
+  }
+}
+
+// exports modules
+module.exports = {
+  cpuInfo,
+  ramMemInfo,
+  osDetail,
+  diskInfo,
+  controllerInfo,
+  displayInfo,
+  biosInfo
+};

package/functions/multipleStack.js

@@ -0,0 +1,77 @@
+// modules
+const { textSync } = require("figlet");
+const Wappalyzer = require("wappalyzer");
+const { red, green } = require("colors");
+const { Table } = require("console-table-printer");
+
+/**
+ *
+ * @description call multiple websites tech stack analyze
+ * @param { string[] } urls - tech analyze in multiples websites
+ * @returns { Promise<void> } - async results in multiples websites
+ * 
+ */
+const multipleStack = async (urls) => {
+  const wappalyzer = await new Wappalyzer();
+
+  const p = new Table({
+    columns: [
+      {
+        name: "techName",
+        alignment: "left",
+        color: "cyan"
+      },
+      {
+        name: "techWebsite",
+        alignment: "left",
+        color: "green"
+      },
+      {
+        name: "techCategories",
+        alignment: "left",
+        color: "cyan"
+      }
+    ]
+  });
+
+  try {
+    await wappalyzer.init();
+
+    const results = await Promise.all(
+      urls.map(async (url) => {
+        const { technologies } = await wappalyzer.open(url).analyze();
+
+        return {
+          url,
+          technologies
+        };
+      }));
+
+    console.info("multiple websites tech stack \n");
+    console.group();
+    // loop web site tech stack
+    results.forEach(({url, technologies}) => {
+      const stackResult = technologies.map(({ 
+        name,
+        website,
+        categories
+      }) => ({
+        techName: name,
+        techWebsite: website,
+        techCategories: categories.map(({ name }) => name).join(", ")
+      }));
+
+      console.info(green(textSync(url, "Small")));
+      console.group();
+      p.addRows(stackResult);
+      p.printTable();
+      console.groupEnd();
+    });
+  } catch (err) {
+    console.error(red(err.message));
+  }
+
+  await wappalyzer.destroy();
+};
+
+module.exports = multipleStack;

package/functions/pageSpeed.js

@@ -0,0 +1,104 @@
+// modules
+const axios = require("axios").default;
+const cliProgress = require("cli-progress");
+const colors = require("colors");
+
+/**
+ * @description get color bar
+ * @param { number } valueOne - get value data desktop
+ * @param { number } valueTwo - get value data mobile
+ * @param { any } bar - using bar
+ * @returns { void }
+ */
+const barColor = (valueOne, valueTwo, bar) => {
+  switch (true) {
+    case (valueOne === 1 || valueOne <= 49):
+    case (valueTwo === 1 || valueTwo <= 49):
+      colors.red(bar);
+      break;
+    case (valueOne === 50 || valueOne <= 89):
+    case (valueTwo === 50 || valueTwo <= 89):
+      colors.yellow(bar);
+      break;
+    case (valueOne >= 90 || valueOne === 100):
+    case (valueTwo >= 90 || valueTwo === 100):
+      colors.green(bar);
+      break;
+    default:
+      colors.bgMagenta(bar);
+      break;
+  }
+};
+
+/**
+ * @description async function mobile website pagespeed
+ * @param { string } url - website from pagespeed mobile results
+ * @returns { Promise<void> } - return async mobile results
+ */
+const pageSpeed = async (url) => {
+  const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+    params: {
+      url,
+      key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+      strategy: "mobile"
+    }
+  });
+
+  const resDesktop = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+    params: {
+      url,
+      key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+      strategy: "desktop"
+    }
+  });
+
+  // extract results
+  const movil = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
+  const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
+
+  // result pagespeed bar color
+  const multibar = new cliProgress.MultiBar({
+    format: " {bar} | {text} | {value}/{total}",
+    clearOnComplete: false,
+    hideCursor: true,
+    barCompleteChar: "\u2588",
+    barIncompleteChar: "\u2591",
+  }, cliProgress.Presets.rect);
+
+  // add bars
+  const b1 = multibar.create(100, 0);
+  const b2 = multibar.create(100, 0);
+
+  try {
+
+    // valid results
+    switch (true) {
+      case (movil === 1 || movil <= 49):
+      case (desktop === 1 || desktop <= 49):
+        b1.update(movil, { text: "mobile result".red });
+        b2.update(desktop, { text: "desktop result".red });
+        break;
+      case (movil === 50 || movil <= 89):
+      case (desktop === 50 || desktop <= 89):
+        b1.update(movil, { text: "mobile result".yellow });
+        b2.update(desktop, { text: "desktop result".yellow });
+        break;
+      case (movil >= 90 || movil === 100):
+      case (desktop >= 90 || desktop === 100):
+        b1.update(movil, { text: "mobile result".green });
+        b2.update(desktop, { text: "desktop result".green });
+        break;
+      default:
+        b1.update(movil, { text: "mobile result" });
+        b2.update(desktop, { text: "desktop result" });
+        break;
+    }
+
+    // stop all bars
+    multibar.stop();
+  } catch (err) {
+    console.error(err.message.red);
+  }
+};
+
+module.exports = pageSpeed;

package/functions/singleStack.js

@@ -0,0 +1,65 @@
+// module
+const Wappalyzer = require("wappalyzer");
+const { textSync } = require("figlet");
+const { red, green } = require("colors");
+const { Table } = require("console-table-printer");
+
+/**
+ * 
+ * @description call single website tech stack analyze
+ * @param { string } url - analyze single website stack
+ * @returns { Promise<void> } - return async results single web
+ * 
+ */
+async function singleStack(url) {
+  const wappalyzer = await new Wappalyzer;
+
+  const p = new Table({
+    columns: [
+      {
+        name: "techName",
+        alignment: "left",
+        color: "cyan"
+      },
+      {
+        name: "techWebsite",
+        alignment: "left",
+        color: "green"
+      },
+      {
+        name: "techCategories",
+        alignment: "left",
+        color: "cyan"
+      }
+    ]
+
+  });
+
+  try {
+    await wappalyzer.init();
+
+    const { technologies } = await wappalyzer.open(url).analyze();
+
+    const stackResult = technologies.map(({
+      name,
+      website,
+      categories
+    }) => ({
+      techName: name,
+      techWebsite: website,
+      techCategories: categories.map(({ name }) => name).join(", ")
+    }));
+
+    console.info(green(textSync(url)));
+
+    p.addRows(stackResult);
+
+    p.printTable();
+  } catch (err) {
+    console.error(red(err.message));
+  }
+
+  await wappalyzer.destroy();
+}
+
+module.exports = singleStack;