netintel-mcp 1.1.0 → 1.1.2

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

@@ -400,6 +400,206 @@ function registerTools(server, api) {
             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);
+        }
+    });
+    // 45. Classify (POST)
+    server.tool("netintel_classify", "Classify text into caller-supplied categories using Claude Haiku — zero-shot classification where the agent provides the label set and gets back the best-matching category with confidence and per-label scores, so agents can route, tag, and…", { text: z.string(), labels: z.array(z.string()), multi_label: z.boolean().optional() }, async ({ text, labels, multi_label }) => {
+        try {
+            const res = await api.post("/classify", { text, labels, multi_label });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 46. Content Moderate (POST)
+    server.tool("netintel_content_moderate", "Moderate text content using Claude Haiku — flags categories like harassment, hate, sexual content, violence, self-harm, and spam with per-category severity and an overall allow/flag/block recommendation, so agents can screen user-generated…", { text: z.string() }, async ({ text }) => {
+        try {
+            const res = await api.post("/content-moderate", { text });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 47. Entity Extract (POST)
+    server.tool("netintel_entity_extract", "Extract named entities from text using Claude Haiku — people, organizations, locations, dates, emails, URLs, money amounts, and products — returned as structured typed arrays so agents can pull structured signals out of unstructured text…", { text: z.string(), types: z.array(z.string()).optional() }, async ({ text, types }) => {
+        try {
+            const res = await api.post("/entity-extract", { text, types });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 48. Sentiment (POST)
+    server.tool("netintel_sentiment", "Analyze the sentiment of text using Claude Haiku — returns overall polarity (positive/negative/neutral/mixed), a -1 to +1 score, detected emotions, and optional per-aspect sentiment, so agents can gauge tone in reviews, messages, and…", { text: z.string(), aspects: z.array(z.string()).optional() }, async ({ text, aspects }) => {
+        try {
+            const res = await api.post("/sentiment/analyze", { text, aspects });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 49. Text Summarize (POST)
+    server.tool("netintel_text_summarize", "Summarize any text or web page into a concise summary plus key bullet points using Claude Haiku — accepts raw text or a URL (which it fetches and extracts), enforces an input cap, and returns a clean structured summary so agents can…", { text: z.string().optional(), url: z.string().optional(), max_points: z.number().optional() }, async ({ text, url, max_points }) => {
+        try {
+            const res = await api.post("/text-summarize", { text, url, max_points });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 50. Translate (POST)
+    server.tool("netintel_translate", "Translate up to 2000 words between languages using Claude Haiku — auto-detects source, supports 30+ target languages, preserves formatting, for larger documents and articles. For short snippets use the cheaper /translate/short.", { text: z.string(), target: z.string(), source: z.string().optional() }, async ({ text, target, source }) => {
+        try {
+            const res = await api.post("/translate/long", { text, target, source });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 51. Translate (POST)
+    server.tool("netintel_translate_short", "Translate up to 500 words between languages using Claude Haiku — auto-detects source language, supports 30+ target languages, preserves formatting, and returns the translation with detected source so agents can localize short content…", { text: z.string(), target: z.string(), source: z.string().optional() }, async ({ text, target, source }) => {
+        try {
+            const res = await api.post("/translate/short", { text, target, source });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 52. Domain Due Diligence
+    server.tool("netintel_domain_due_diligence", "One call combines domain availability, heuristic value appraisal, and TLD pricing into a single acquisition brief — tells an agent whether a name is available, what it's worth, and what it costs across TLDs, concurrently and with graceful…", { domain: z.string() }, async ({ domain }) => {
+        try {
+            const res = await api.get("/domain-due-diligence", { params: { domain } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 53. Domain Report
+    server.tool("netintel_domain_report_full", "One premium call returns a complete six-part domain profile — DNS records, SSL certificate, WHOIS registration, cloud fingerprint, technology stack, and security headers — each section run concurrently with graceful partial-failure…", { domain: z.string() }, async ({ domain }) => {
+        try {
+            const res = await api.get("/domain-report/full", { params: { domain } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 54. Email Report
+    server.tool("netintel_email_report", "One call combines domain email authentication (SPF/DKIM/DMARC), email-address intelligence (deliverability, disposable/role detection), and an optional password breach check into a single email-trust report — each section run concurrently…", { email: z.string(), password: z.string().optional() }, async ({ email, password }) => {
+        try {
+            const res = await api.get("/email-report/full", { params: params({ email, password }) });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 55. Ip Report
+    server.tool("netintel_ip_report", "One premium call returns a complete five-part IP profile — geolocation, ASN/network ownership, multi-DNSBL blacklist status, threat reputation, and an aggregate risk verdict — run concurrently with graceful partial-failure handling, so…", { ip: z.string() }, async ({ ip }) => {
+        try {
+            const res = await api.get("/ip-report/full", { params: { ip } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    // 56. Url Safety
+    server.tool("netintel_url_safety_full", "One call vets a URL end to end — traces its full redirect chain, checks it against malware/phishing databases, audits its security headers, and inspects its SSL certificate — concurrent with graceful partial-failure handling, so agents get…", { url: z.string() }, async ({ url }) => {
+        try {
+            const res = await api.get("/url-safety/full", { params: { url } });
+            return ok(res.data);
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
 }
 async function main() {
     const api = await createClient();

package/package.json

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