netintel-mcp 1.0.1 → 1.1.1

package/README.md

@@ -1,6 +1,6 @@
 # netintel-mcp
 
-MCP server for NetIntel — 25 network intelligence tools for AI agents.
+MCP server for NetIntel — 36 network intelligence tools for AI agents.
 DNS, SSL, WHOIS, email security, cloud fingerprinting, OSINT and more.
 Pay-per-call via x402 on Base mainnet. No API keys needed — just a wallet with USDC.
 
@@ -58,6 +58,17 @@ Or add manually to your Claude Desktop config:
 | netintel_rss_parser | RSS/Atom feed parser | $0.001 |
 | netintel_username_check | Username availability (20+ platforms) | $0.003 |
 | netintel_wayback_lookup | Wayback Machine snapshots | $0.001 |
+| netintel_ip_reputation | IP reputation via AbuseIPDB + AlienVault OTX | $0.010 |
+| netintel_cron_parser | Parse cron expressions, explain schedule | $0.001 |
+| netintel_currency_exchange | Convert between 32 currencies | $0.001 |
+| netintel_github_intel | GitHub repo metrics and maintenance score | $0.001 |
+| netintel_holidays | Public holidays by country | $0.001 |
+| netintel_ip_geo | IP geolocation — country, city, ISP, ASN | $0.001 |
+| netintel_jwt_inspector | Decode JWT tokens, flag security issues | $0.001 |
+| netintel_lang_detect | Detect language with confidence scoring | $0.001 |
+| netintel_npm_intel | npm package analysis and quality score | $0.001 |
+| netintel_sitemap_parser | Parse XML sitemaps, extract URL metadata | $0.001 |
+| netintel_url_safety | Check URL against URLhaus + heuristics | $0.002 |
 
 ## Payment
 All tools pay automatically via x402 on Base mainnet (USDC).

package/dist/index.js

@@ -286,12 +286,206 @@ function registerTools(server, api) {
             return err(e);
         }
     });
+    // 26. IP Reputation
+    server.tool("netintel_ip_reputation", "Check IP against AbuseIPDB and AlienVault OTX. Returns composite risk score, threat categories, and malware families.", { ip: z.string() }, async ({ ip }) => {
+        try {
+            const res = await api.get("/ip-reputation/analyze", { params: { ip } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 27. Cron Parser
+    server.tool("netintel_cron_parser", "Parse a cron expression, explain the schedule in plain English, and compute the next 5 run times.", { expression: z.string() }, async ({ expression }) => {
+        try {
+            const res = await api.get("/cron-parser/explain", { params: { expression } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 28. Currency Exchange
+    server.tool("netintel_currency_exchange", "Convert between 32 currencies with real-time or historical rates. Pass a date (YYYY-MM-DD) for historical lookup.", { from: z.string(), to: z.string(), amount: z.number().optional(), date: z.string().optional() }, async ({ from, to, amount, date }) => {
+        try {
+            const res = await api.get("/currency-exchange/convert", {
+                params: params({ from, to, amount, date }),
+            });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 29. GitHub Intel
+    server.tool("netintel_github_intel", "Analyze a GitHub repo — stars, forks, activity, license, open issues, maintenance score. Pass owner/repo format.", { repo: z.string() }, async ({ repo }) => {
+        try {
+            const res = await api.get("/github-intel/analyze", { params: { repo } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 30. Holidays
+    server.tool("netintel_holidays", "Get public holidays by country. Check if a date is a business day or weekend. ISO 3166-1 alpha-2 country codes.", { country: z.string(), year: z.number().optional(), month: z.number().optional() }, async ({ country, year, month }) => {
+        try {
+            const res = await api.get("/holidays/check", {
+                params: params({ country, year, month }),
+            });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 31. IP Geo
+    server.tool("netintel_ip_geo", "Geolocate an IP address — country, city, coordinates, ISP, ASN, timezone.", { ip: z.string() }, async ({ ip }) => {
+        try {
+            const res = await api.get("/ip-geo/locate", { params: { ip } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 32. JWT Inspector
+    server.tool("netintel_jwt_inspector", "Decode a JWT token — inspect header and payload, check expiry, flag security issues like weak algorithms.", { token: z.string() }, async ({ token }) => {
+        try {
+            const res = await api.get("/jwt-inspector/decode", { params: { token } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 33. Lang Detect (POST)
+    server.tool("netintel_lang_detect", "Detect the language of any text with confidence scoring. Supports 50+ languages.", { text: z.string() }, async ({ text }) => {
+        try {
+            const res = await api.post("/lang-detect/analyze", { text });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 34. npm Intel
+    server.tool("netintel_npm_intel", "Analyze an npm package — versions, weekly downloads, maintainers, dependencies, quality and maintenance score.", { package: z.string() }, async (args) => {
+        try {
+            const res = await api.get("/npm-intel/analyze", { params: { package: args.package } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 35. Sitemap Parser
+    server.tool("netintel_sitemap_parser", "Parse an XML sitemap or auto-discover it from a domain. Returns all URLs with metadata including lastmod and priority.", { url: z.string() }, async ({ url }) => {
+        try {
+            const res = await api.get("/sitemap-parser/fetch", { params: { url } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 36. URL Safety
+    server.tool("netintel_url_safety", "Check a URL against URLhaus malware database and heuristic analysis. Returns threat classification and risk score.", { url: z.string() }, async ({ url }) => {
+        try {
+            const res = await api.get("/url-safety/check", { params: { url } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 37. Domain Age
+    server.tool("netintel_domain_age", "Determine a domain's age from registration data and archival history — returns creation date, age in years, first Wayback Machine capture, total archived snapshots, and a maturity signal so agents can assess domain trustworthiness and…", { domain: z.string() }, async ({ domain }) => {
+        try {
+            const res = await api.get("/domain-age/check", { params: { domain } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 38. Bulk Domain (POST)
+    server.tool("netintel_bulk_domain", "Check availability of many domain names across multiple TLDs in a single call — submit up to 50 name/TLD combinations and get back per-domain registration status, registrar, and expiry concurrently, so agents can scan an entire naming…", { names: z.array(z.string()), tlds: z.array(z.string()).optional() }, async ({ names, tlds }) => {
+        try {
+            const res = await api.post("/bulk-domain/check", { names, tlds });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 39. Domain Appraise
+    server.tool("netintel_domain_appraise", "Estimate the market value tier of a domain name using transparent heuristics — length, TLD premium, dictionary-word presence, pronounceability, keyword value, and numeric/hyphen penalties — returns a value tier and 0-100 quality score so…", { domain: z.string() }, async ({ domain }) => {
+        try {
+            const res = await api.get("/domain-appraise/estimate", { params: { domain } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 40. Domain Report
+    server.tool("netintel_domain_report", "One call returns a complete intelligence profile for a domain — WHOIS registration, DNS records, SSL certificate, detected tech stack, and blacklist status — aggregated into a single risk-scored report so agents can fully vet a domain…", { domain: z.string() }, async ({ domain }) => {
+        try {
+            const res = await api.get("/domain-report/analyze", { params: { domain } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 41. Ip Risk
+    server.tool("netintel_ip_risk", "One call returns a complete risk profile for an IP address — geolocation, ASN/network owner, blacklist status across multiple DNSBLs, and proxy/VPN/hosting classification — aggregated into a single verdict so agents can make a block/allow…", { ip: z.string() }, async ({ ip }) => {
+        try {
+            const res = await api.get("/ip-risk/score", { params: { ip } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 42. Name Gen
+    server.tool("netintel_name_gen", "Generate brandable startup/product names from a keyword using prefixes, suffixes, blends, and phonetic patterns, then check .com (or any TLD) availability for each via DNS — returns available names ranked by a brandability heuristic so…", { keyword: z.string(), tld: z.string().optional(), limit: z.number().optional() }, async ({ keyword, tld, limit }) => {
+        try {
+            const res = await api.get("/name-gen/suggest", { params: params({ keyword, tld, limit }) });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 43. Tld Price
+    server.tool("netintel_tld_price", "Compare registration, renewal, and transfer prices for a TLD across major registrars, or for a single domain name across many TLDs — returns sorted reference pricing so agents can find the cheapest place to register, budget domain…", { tld: z.string().optional(), name: z.string().optional() }, async ({ tld, name }) => {
+        try {
+            const res = await api.get("/tld-price/compare", { params: params({ tld, name }) });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 44. Typosquat
+    server.tool("netintel_typosquat", "Generate common typo and look-alike variations of a domain and check which are already registered — catches character swaps, omissions, additions, homoglyphs, and alternate TLDs so agents can detect typosquatting and brand-impersonation…", { domain: z.string(), limit: z.number().optional() }, async ({ domain, limit }) => {
+        try {
+            const res = await api.get("/typosquat/scan", { params: params({ domain, limit }) });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
 }
 async function main() {
     const api = await createClient();
     const server = new McpServer({
         name: "netintel-mcp",
-        version: "1.0.0",
+        version: "1.1.0",
     });
     registerTools(server, api);
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netintel-mcp",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "mcpName": "io.github.kjgueye/netintel-mcp",
   "repository": {
     "type": "git",