vh-dev-helper 0.0.0-stage → 1.0.0

package/dist/src/services/network/network.service.js

@@ -0,0 +1,524 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkService = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const exec_1 = require("../../core/shell/exec");
+class NetworkService {
+    async discover(target) {
+        try {
+            console.log(chalk_1.default.cyan.bold("\n📡 NETWORK DISCOVERY\n"));
+            if (target === "localhost") {
+                await this.discoverLocal();
+                return;
+            }
+            if (target.includes("/")) {
+                await this.discoverSubnet(target);
+                return;
+            }
+            const privateIp = /^(10\.|172\.|192\.168)/.test(target);
+            if (privateIp) {
+                await this.inspectDevice(target);
+                return;
+            }
+            await this.discoverHost(target);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    async discoverLocal() {
+        console.log(chalk_1.default.yellow("🌐 Discovering Local Devices\n"));
+        const subnet = (await (0, exec_1.exec)(`
+ipconfig getifaddr en0 |
+awk -F. '{print $1"."$2"."$3".0/24"}'
+`, true)).trim();
+        console.log(`Subnet : ${subnet}\n`);
+        await this.discoverSubnet(subnet);
+    }
+    async discoverSubnet(subnet) {
+        console.log(chalk_1.default.yellow("🔍 Scanning subnet...\n"));
+        await (0, exec_1.exec)(`
+for ip in $(seq 1 254)
+do
+ ping -c 1 -W 1 ${subnet.replace("/24", "")}.$ip >/dev/null 2>&1 &
+done
+
+wait
+`, true);
+        const arp = await (0, exec_1.exec)(`arp -a`, true);
+        const devices = arp.split("\n").filter(Boolean);
+        console.log(chalk_1.default.yellow("📱 Devices"));
+        for (const line of devices) {
+            const ip = line.match(/\((.*?)\)/)?.[1];
+            const mac = line.match(/at (.*?) /)?.[1];
+            if (!ip) {
+                continue;
+            }
+            console.log(`${chalk_1.default.green(ip)} | ${mac || "Unknown MAC"}`);
+        }
+        console.log(chalk_1.default.green("\n✅ Discovery Complete\n"));
+    }
+    async inspectDevice(ip) {
+        console.log(chalk_1.default.yellow("🖥 Device Inspection\n"));
+        const hostname = (await (0, exec_1.exec)(`nslookup ${ip}`, true))
+            .split("\n")
+            .find((x) => x.includes("name"));
+        console.log(`IP        : ${ip}`);
+        console.log(`Hostname  : ${hostname || "Unknown"}`);
+        console.log("\nScanning ports...\n");
+        await this.ports(ip, {});
+    }
+    async discoverHost(host) {
+        console.log(chalk_1.default.yellow("🌐 Host Discovery\n"));
+        const ip = (await (0, exec_1.exec)(`dig +short ${host} | head -n1`, true)).trim();
+        const info = JSON.parse(await (0, exec_1.exec)(`curl -s ipinfo.io/${ip}`, true));
+        console.log(`Domain     : ${host}`);
+        console.log(`IP         : ${ip}`);
+        console.log(`Provider   : ${info.org}`);
+        console.log(`Country    : ${info.country}`);
+        console.log(`Region     : ${info.region}`);
+        console.log("\nPort Scan\n");
+        await this.ports(host, {});
+    }
+    async ports(host, options) {
+        try {
+            console.log(chalk_1.default.cyan.bold("\n🔌 PORT SCAN\n"));
+            console.log(chalk_1.default.yellow("🎯 Target"));
+            console.log(`Host : ${host}\n`);
+            const DEFAULT = [
+                [22, "SSH"],
+                [80, "HTTP"],
+                [443, "HTTPS"],
+                [3306, "MySQL"],
+                [5432, "Postgres"],
+                [6379, "Redis"],
+                [27017, "MongoDB"],
+                [3000, "Node"],
+                [8080, "HTTP Alt"],
+                [21, "FTP"],
+                [25, "SMTP"],
+                [53, "DNS"],
+                [110, "POP3"],
+                [143, "IMAP"],
+            ];
+            const EXTENDED = [
+                ...DEFAULT,
+                [23, "TELNET"],
+                [445, "SMB"],
+                [587, "SMTP"],
+                [993, "IMAPS"],
+                [995, "POP3S"],
+                [3389, "RDP"],
+                [5900, "VNC"],
+                [9200, "Elastic"],
+                [8443, "HTTPS Alt"],
+                [9092, "Kafka"],
+                [2375, "Docker"],
+                [27018, "Mongo Replica"],
+                [5000, "Flask"],
+                [4000, "Dev"],
+            ];
+            let ports;
+            if (options.ports) {
+                ports = options.ports
+                    .split(",")
+                    .map((x) => Number(x.trim()))
+                    .filter(Boolean)
+                    .map((p) => [p, "Custom"]);
+            }
+            else if (options.full) {
+                ports = Array.from({
+                    length: 65535,
+                }, (_, i) => [i + 1, "Unknown"]);
+            }
+            else if (options.extended) {
+                ports = EXTENDED;
+            }
+            else {
+                ports = DEFAULT;
+            }
+            console.log(chalk_1.default.yellow("🔎 Scanning"));
+            console.log(`Ports : ${ports.length}\n`);
+            const start = Date.now();
+            const BATCH = options.full ? 100 : 50;
+            const openPorts = [];
+            for (let i = 0; i < ports.length; i += BATCH) {
+                const chunk = ports.slice(i, i + BATCH);
+                const results = await Promise.all(chunk.map(async ([port, service]) => {
+                    try {
+                        await (0, exec_1.exec)(`
+nc \
+-z \
+-G 1 \
+${host} \
+${port}
+`, true);
+                        return {
+                            port,
+                            service,
+                            open: true,
+                        };
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                openPorts.push(...results.filter(Boolean));
+                process.stdout.write(`Progress : ${Math.min(i + BATCH, ports.length)}/${ports.length}\r`);
+            }
+            console.log("\n");
+            console.log(chalk_1.default.yellow("📂 Open Ports"));
+            if (!openPorts.length) {
+                console.log(chalk_1.default.red("No open ports found"));
+            }
+            openPorts.forEach((port) => {
+                console.log(`${chalk_1.default.green(port.port)} → ${port.service}`);
+            });
+            console.log("\n");
+            console.log(chalk_1.default.yellow("📊 Summary"));
+            console.log(`Ports Checked : ${ports.length}`);
+            console.log(`Open Ports    : ${openPorts.length}`);
+            console.log(`Scan Time     : ${Date.now() - start} ms`);
+            console.log("\n");
+            console.log(chalk_1.default.yellow("🚨 Analysis"));
+            if (openPorts.some((x) => x.port === 22)) {
+                console.log(chalk_1.default.yellow("SSH reachable from internet"));
+            }
+            const databases = openPorts.filter((x) => [3306, 5432, 6379, 27017].includes(x.port));
+            if (databases.length) {
+                console.log(chalk_1.default.red("Database services exposed"));
+            }
+            console.log(chalk_1.default.green("\n✅ Scan complete\n"));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red("❌ Scan failed"));
+            console.error(error);
+        }
+    }
+    async trace(host) {
+        try {
+            console.log(chalk_1.default.cyan.bold("\n🛰 NETWORK TRACE\n"));
+            console.log(chalk_1.default.yellow("🎯 Target"));
+            console.log(`Host : ${host}\n`);
+            const resolvedIp = (await (0, exec_1.exec)(`dig +short ${host} | head -n1`, true)).trim();
+            console.log(chalk_1.default.yellow("🌍 DNS Resolution"));
+            console.log(`Resolved IP : ${resolvedIp}\n`);
+            console.log(chalk_1.default.gray("Fast tracing...\n"));
+            const raw = await (0, exec_1.exec)(`
+traceroute \
+-m 8 \
+-q 1 \
+-w 200 \
+-n \
+${host}
+`, true);
+            const hops = raw.split("\n").slice(1).filter(Boolean);
+            const uniqueIps = new Set();
+            let timeoutCount = 0;
+            let latencyTotal = 0;
+            let latencyCount = 0;
+            for (const hop of hops) {
+                const ip = hop.match(/(\d+\.\d+\.\d+\.\d+)/)?.[1];
+                if (ip && !ip.match(/^(10\.|172\.|192\.168|127\.|169\.254)/)) {
+                    uniqueIps.add(ip);
+                }
+            }
+            console.log(chalk_1.default.gray(`Enriching ${uniqueIps.size} public hops...\n`));
+            const ipCache = new Map();
+            await Promise.all([...uniqueIps].map(async (ip) => {
+                try {
+                    const result = await (0, exec_1.exec)(`curl -s --max-time 1 ipinfo.io/${ip}`, true);
+                    ipCache.set(ip, JSON.parse(result));
+                }
+                catch { }
+            }));
+            console.log(chalk_1.default.yellow("📍 Hop Details"));
+            for (const hop of hops) {
+                const cleaned = hop.trim();
+                if (cleaned.includes("*")) {
+                    timeoutCount++;
+                    console.log(chalk_1.default.red(cleaned));
+                    continue;
+                }
+                const ip = cleaned.match(/(\d+\.\d+\.\d+\.\d+)/)?.[1];
+                const latency = cleaned.match(/([0-9.]+)\s*ms/)?.[1];
+                if (latency) {
+                    latencyTotal += Number(latency);
+                    latencyCount++;
+                }
+                let extra = "";
+                if (ipCache.has(ip)) {
+                    const info = ipCache.get(ip);
+                    extra = chalk_1.default.gray(` | ${info.org || "Unknown"} | ${info.country || ""}`);
+                }
+                else if (ip) {
+                    extra = chalk_1.default.gray(" | Private");
+                }
+                console.log(`${cleaned}${extra}`);
+            }
+            console.log("");
+            console.log(chalk_1.default.yellow("📊 Statistics"));
+            console.log(`Hop Count      : ${hops.length}`);
+            console.log(`Timeout Hops   : ${timeoutCount}`);
+            console.log(`Public Hops    : ${uniqueIps.size}`);
+            console.log(`Avg Latency    : ${latencyCount ? (latencyTotal / latencyCount).toFixed(2) : "N/A"} ms`);
+            console.log("");
+            console.log(chalk_1.default.yellow("🚨 Analysis"));
+            if (timeoutCount > 2) {
+                console.log(chalk_1.default.yellow("Packet filtering detected"));
+            }
+            console.log(chalk_1.default.green("\n✅ Trace complete\n"));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red("❌ Trace failed"));
+            console.error(error);
+        }
+    }
+    async ssl(domain) {
+        try {
+            console.log(chalk_1.default.cyan.bold("\n🔐 SSL INSPECT\n"));
+            console.log(`Domain : ${domain}\n`);
+            const cert = await (0, exec_1.exec)(`
+echo | openssl s_client \
+-connect ${domain}:443 \
+-servername ${domain} \
+-status \
+2>/dev/null |
+openssl x509 -text -fingerprint -noout
+`, true);
+            const subject = cert.match(/Subject:\s*(.*)/)?.[1] || "Unknown";
+            const issuer = cert.match(/Issuer:\s*(.*)/)?.[1] || "Unknown";
+            const issued = cert.match(/Not Before:\s*(.*)/)?.[1] || "Unknown";
+            const expiry = cert.match(/Not After :\s*(.*)/)?.[1] || "Unknown";
+            const serial = cert.match(/Serial Number:\s*([A-Fa-f0-9:\s]+)/)?.[1]?.trim() ||
+                "Unknown";
+            const signature = cert.match(/Signature Algorithm:\s*(.*)/)?.[1] || "Unknown";
+            const keySize = cert.match(/Public-Key: \((.*?) bit\)/)?.[1] || "Unknown";
+            const fingerprint = cert.match(/SHA1 Fingerprint=(.*)/)?.[1] || "Unknown";
+            const org = subject.match(/O\s*=\s*([^,]+)/)?.[1];
+            const country = subject.match(/C\s*=\s*([^,]+)/)?.[1];
+            const sans = [...cert.matchAll(/DNS:([^,\n]+)/g)].map((m) => m[1]);
+            const protocol = await (0, exec_1.exec)(`
+echo | openssl s_client \
+-connect ${domain}:443 \
+-servername ${domain} \
+2>/dev/null |
+grep "Protocol"
+`, true);
+            const cipher = await (0, exec_1.exec)(`
+echo | openssl s_client \
+-connect ${domain}:443 \
+-servername ${domain} \
+2>/dev/null |
+grep "Cipher is"
+`, true);
+            const verify = await (0, exec_1.exec)(`
+echo | openssl s_client \
+-connect ${domain}:443 \
+-servername ${domain} \
+2>/dev/null |
+grep "Verify return code"
+`, true);
+            const headers = await (0, exec_1.exec)(`curl -I -s https://${domain}`, true);
+            const expiryDate = new Date(expiry);
+            const issuedDate = new Date(issued);
+            const daysLeft = Math.ceil((expiryDate.getTime() - Date.now()) / 86400000);
+            const certAge = Math.floor((Date.now() - issuedDate.getTime()) / 86400000);
+            const wildcard = sans.some((s) => s.includes("*"));
+            const selfSigned = issuer === subject;
+            const hsts = headers.toLowerCase().includes("strict-transport-security");
+            const ocsp = headers.toLowerCase().includes("ocsp");
+            console.log(chalk_1.default.yellow("🏢 Ownership"));
+            console.log(`Subject       : ${subject}`);
+            console.log(`Organization  : ${org || "Not Available"}`);
+            console.log(`Country       : ${country || "Not Available"}`);
+            console.log(`Issued By     : ${issuer}`);
+            console.log("");
+            console.log(chalk_1.default.yellow("📅 Validity"));
+            console.log(`Issued On     : ${issued}`);
+            console.log(`Expires On    : ${expiry}`);
+            console.log(`Cert Age      : ${certAge} days`);
+            console.log(`Days Left     : ${daysLeft}`);
+            console.log("");
+            console.log(chalk_1.default.yellow("🔒 Security"));
+            console.log(protocol.trim());
+            console.log(cipher.trim());
+            console.log(`Public Key    : ${keySize} bit`);
+            console.log(`Signature     : ${signature}`);
+            console.log(`Fingerprint   : ${fingerprint}`);
+            console.log(`Serial        : ${serial}`);
+            console.log("");
+            console.log(chalk_1.default.yellow("🛡 Trust"));
+            console.log(`Self Signed   : ${selfSigned ? "Yes" : "No"}`);
+            console.log(`Trust Status  : ${verify.trim()}`);
+            console.log("");
+            console.log(chalk_1.default.yellow("🌍 Domains"));
+            console.log(`Wildcard      : ${wildcard ? "Yes" : "No"}`);
+            console.log(`SAN Count     : ${sans.length}`);
+            sans.slice(0, 10).forEach((s) => console.log(`  • ${s}`));
+            if (sans.length > 10) {
+                console.log(`  ... +${sans.length - 10} more`);
+            }
+            console.log("");
+            console.log(chalk_1.default.yellow("⚙ Transport"));
+            console.log(`HSTS          : ${hsts ? "Enabled" : "Disabled"}`);
+            console.log(`OCSP          : ${ocsp ? "Present" : "Not Found"}`);
+            console.log("");
+            console.log(chalk_1.default.yellow("🚨 Status"));
+            if (daysLeft < 15) {
+                console.log(chalk_1.default.red("Certificate expiring soon"));
+            }
+            else if (daysLeft < 45) {
+                console.log(chalk_1.default.yellow("Monitor renewal"));
+            }
+            else {
+                console.log(chalk_1.default.green("Healthy certificate"));
+            }
+            console.log(chalk_1.default.green("\n✅ SSL inspection complete\n"));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red("❌ SSL inspection failed"));
+            console.error(error);
+        }
+    }
+    async inspect(input) {
+        try {
+            const domain = input.replace(/^https?:\/\//, "").split("/")[0];
+            const random = Date.now();
+            const testUrl = `${input}${input.includes("?") ? "&" : "?"}nocache=${random}`;
+            console.log(chalk_1.default.cyan.bold("\n🌐 NETWORK INSPECT"));
+            console.log(chalk_1.default.gray(`Target : ${input}`));
+            console.log(chalk_1.default.gray(`Domain : ${domain}`));
+            console.log("");
+            await this.showDns(domain);
+            await this.showIp(domain);
+            await this.showRedirects(input);
+            await this.showHeaders(input);
+            await this.showStats(testUrl, false);
+            await this.showStats(testUrl, true);
+            console.log(chalk_1.default.green("\n✅ Done\n"));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red("\n❌ Inspection failed"));
+            console.error(error);
+        }
+    }
+    formatTime(value) {
+        const num = Number(value);
+        if (num < 1) {
+            return `${(num * 1000).toFixed(3)} ms`;
+        }
+        return `${num.toFixed(3)} s`;
+    }
+    async showDns(domain) {
+        console.log(chalk_1.default.yellow("📡 DNS"));
+        const resolver = "8.8.8.8";
+        console.log(chalk_1.default.gray("\nResolver Used:"));
+        console.log(`  ${resolver} (Google DNS)`);
+        const ns = await (0, exec_1.exec)(`dig NS +short ${domain}`, true);
+        const nameservers = ns.split("\n").filter(Boolean);
+        console.log(chalk_1.default.gray("\nNameservers:"));
+        if (nameservers.length) {
+            nameservers.forEach((server) => console.log(`  ${server}`));
+        }
+        else {
+            console.log("  none");
+        }
+        const cname = await (0, exec_1.exec)(`dig CNAME +short ${domain}`, true);
+        console.log(chalk_1.default.gray("\nCNAME:"));
+        console.log(cname.trim() || "  none");
+        const records = await (0, exec_1.exec)(`dig A +short ${domain}`, true);
+        console.log(chalk_1.default.gray("\nA Records:"));
+        records
+            .split("\n")
+            .filter(Boolean)
+            .forEach((ip) => {
+            console.log(`  ${domain} → ${chalk_1.default.green(ip)}`);
+        });
+        console.log("");
+    }
+    async showIp(domain) {
+        const ip = (await (0, exec_1.exec)(`dig +short ${domain} | head -n1`, true)).trim();
+        console.log(chalk_1.default.yellow("🌍 IP INFO"));
+        console.log(`Resolved IP : ${chalk_1.default.green(ip)}`);
+        if (!ip) {
+            console.log("");
+            return;
+        }
+        const raw = await (0, exec_1.exec)(`curl -s ipinfo.io/${ip}`, true);
+        const info = JSON.parse(raw);
+        console.log(`Country     : ${info.country}`);
+        console.log(`City        : ${info.city}`);
+        console.log(`Region      : ${info.region}`);
+        console.log(`Provider    : ${info.org}`);
+        console.log(`Timezone    : ${info.timezone}`);
+        console.log("");
+    }
+    async showRedirects(url) {
+        console.log(chalk_1.default.yellow("↪ Redirect Chain"));
+        const chain = await (0, exec_1.exec)(`
+curl -sIL "${url}" |
+grep -Ei "HTTP/|location:"
+`, true);
+        console.log(chain.trim() || "No redirects");
+        console.log("");
+    }
+    async showHeaders(url) {
+        console.log(chalk_1.default.yellow("🖥 Headers"));
+        const headers = await (0, exec_1.exec)(`curl -I -s "${url}"`, true);
+        headers
+            .split("\n")
+            .filter((line) => {
+            const lower = line.toLowerCase();
+            return (lower.startsWith("server") ||
+                lower.startsWith("cache-control") ||
+                lower.startsWith("content-type"));
+        })
+            .forEach((line) => console.log(line.trim()));
+        console.log("");
+    }
+    async showStats(url, follow) {
+        console.log(chalk_1.default.yellow(follow ? "📊 With Redirects" : "📊 Without Redirects"));
+        const raw = await (0, exec_1.exec)(`
+curl ${follow ? "-L" : ""} \
+-o /dev/null \
+-s \
+-w "
+HTTP:%{http_code}
+DNS:%{time_namelookup}
+TCP:%{time_connect}
+TLS:%{time_appconnect}
+TTFB:%{time_starttransfer}
+TOTAL:%{time_total}
+REDIRECT:%{time_redirect}
+COUNT:%{num_redirects}
+REMOTE:%{remote_ip}
+TYPE:%{content_type}
+" \
+"${url}"
+`, true);
+        const stats = Object.fromEntries(raw
+            .trim()
+            .split("\n")
+            .map((line) => line.split(":")));
+        console.log(`HTTP        : ${stats.HTTP}`);
+        console.log(`DNS         : ${this.formatTime(stats.DNS)}`);
+        console.log(`TCP         : ${this.formatTime(stats.TCP)}`);
+        console.log(`TLS         : ${this.formatTime(stats.TLS)}`);
+        console.log(`TTFB        : ${this.formatTime(stats.TTFB)}`);
+        console.log(`TOTAL       : ${this.formatTime(stats.TOTAL)}`);
+        console.log(`REDIRECT    : ${this.formatTime(stats.REDIRECT)}`);
+        console.log(`COUNT       : ${stats.COUNT}`);
+        console.log(`REMOTE IP   : ${stats.REMOTE}`);
+        console.log(`TYPE        : ${stats.TYPE}`);
+        const total = Number(stats.TOTAL);
+        if (total > 1) {
+            console.log(chalk_1.default.red("⚠ Slow response detected"));
+        }
+        console.log("");
+    }
+}
+exports.networkService = new NetworkService();

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "vh-dev-helper",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "type": "commonjs",
+  "bin": {
+    "vh": "dist/bin/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx bin/index.ts",
+    "prepack": "npm run build",
+    "completion": "tabtab install vh"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "@types/express": "^5.0.6",
+    "@types/pidusage": "^2.0.5",
+    "@types/ws": "^8.18.1",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "express": "^5.2.1",
+    "open": "^11.0.0",
+    "pidusage": "^4.0.1",
+    "systeminformation": "^5.31.7",
+    "tabtab": "^3.0.2",
+    "ws": "^8.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.