blackveil-dns 2.3.5 → 2.6.2

package/dist/stdio.js

@@ -216,7 +216,8 @@ __export(cache_exports, {
   cacheGet: () => cacheGet,
   cacheSet: () => cacheSet,
   cacheSetDeferred: () => cacheSetDeferred,
-  runWithCache: () => runWithCache
+  runWithCache: () => runWithCache,
+  runWithCacheTracked: () => runWithCacheTracked
 });
 async function cacheGet(key, kv) {
   if (kv) {
@@ -289,6 +290,14 @@ async function runWithCache(key, run, kv, ttlSeconds, skipCache) {
   INFLIGHT.set(key, promise);
   return promise;
 }
+async function runWithCacheTracked(key, run, kv, ttlSeconds, skipCache) {
+  if (!skipCache) {
+    const cached = await cacheGet(key, kv);
+    if (cached !== void 0) return { data: cached, cacheStatus: "hit" };
+  }
+  const data = await runWithCache(key, run, kv, ttlSeconds, true);
+  return { data, cacheStatus: "miss" };
+}
 async function pollForResult(key, kv) {
   for (const delay of POLL_DELAYS_MS) {
     await new Promise((r) => setTimeout(r, delay));
@@ -9684,7 +9693,8 @@ function logToolSuccess(options) {
     cacheStatus: options.cacheStatus,
     country: options.country,
     clientType: options.clientType,
-    authTier: options.authTier
+    authTier: options.authTier,
+    keyHash: options.keyHash
   });
   logEvent({
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9707,7 +9717,8 @@ function logToolFailure(options) {
     cacheStatus: options.cacheStatus,
     country: options.country,
     clientType: options.clientType,
-    authTier: options.authTier
+    authTier: options.authTier,
+    keyHash: options.keyHash
   });
   logError(options.error instanceof Error ? options.error : String(options.error), {
     tool: options.toolName,
@@ -9724,6 +9735,15 @@ function mcpError(message) {
 function mcpText(text) {
   return { type: "text", text };
 }
+function buildToolContent(text, structuredData, format) {
+  const content = [mcpText(text)];
+  if (format === "full") {
+    content.push(mcpText(`<!-- STRUCTURED_RESULT
+${JSON.stringify(structuredData)}
+STRUCTURED_RESULT -->`));
+  }
+  return content;
+}
 function formatCheckResult(result, format = "full") {
   const lines = [];
   lines.push(`## ${result.category.toUpperCase()} Check`);
@@ -10153,7 +10173,8 @@ function handleExplainFindingValidationError(args, durationMs, runtimeOptions) {
     severity: "warn",
     country: runtimeOptions?.country,
     clientType: runtimeOptions?.clientType,
-    authTier: runtimeOptions?.authTier
+    authTier: runtimeOptions?.authTier,
+    keyHash: runtimeOptions?.keyHash
   });
   return buildToolErrorResult(error2.message);
 }
@@ -10179,7 +10200,7 @@ async function handleToolsCall(params, scanCacheKV, runtimeOptions) {
       if (registeredTool) {
         const checkName = registeredTool.cacheKey(validatedArgs);
         const cacheKey = `cache:${validDomain}:check:${checkName}`;
-        const result = await runWithCache(cacheKey, () => registeredTool.execute(validDomain, validatedArgs, runtimeOptions), scanCacheKV, registeredTool.cacheTtlSeconds);
+        const { data: result, cacheStatus } = await runWithCacheTracked(cacheKey, () => registeredTool.execute(validDomain, validatedArgs, runtimeOptions), scanCacheKV, registeredTool.cacheTtlSeconds);
         if (result.partial && scanCacheKV) {
           try {
             await scanCacheKV.delete(cacheKey);
@@ -10199,9 +10220,11 @@ async function handleToolsCall(params, scanCacheKV, runtimeOptions) {
           logDetails,
           country: runtimeOptions?.country,
           clientType: runtimeOptions?.clientType,
-          authTier: runtimeOptions?.authTier
+          authTier: runtimeOptions?.authTier,
+          keyHash: runtimeOptions?.keyHash,
+          cacheStatus
         });
-        return { content: [mcpText(formatCheckResult(result, effectiveFormat))] };
+        return { content: buildToolContent(formatCheckResult(result, effectiveFormat), result, effectiveFormat) };
       }
       switch (name) {
         case "scan_domain": {
@@ -10222,16 +10245,11 @@ async function handleToolsCall(params, scanCacheKV, runtimeOptions) {
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          const content = [mcpText(formatScanReport(result, effectiveFormat))];
-          if (effectiveFormat === "full") {
-            const structured = buildStructuredScanResult(result);
-            content.push(mcpText(`<!-- STRUCTURED_RESULT
-${JSON.stringify(structured)}
-STRUCTURED_RESULT -->`));
-          }
-          return { content };
+          const structured = buildStructuredScanResult(result);
+          return { content: buildToolContent(formatScanReport(result, effectiveFormat), structured, effectiveFormat) };
         }
         case "batch_scan": {
           const domains = validatedArgs.domains;
@@ -10260,9 +10278,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(batchText)] };
+          return { content: buildToolContent(batchText, batchResults, effectiveFormat) };
         }
         case "compare_domains": {
           const domains = validatedArgs.domains;
@@ -10289,9 +10308,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(compareText)] };
+          return { content: buildToolContent(compareText, compareResults, effectiveFormat) };
         }
         case "compare_baseline": {
           const baseline = extractBaseline(validatedArgs);
@@ -10310,9 +10330,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatBaselineResult(result, effectiveFormat))] };
+          return { content: buildToolContent(formatBaselineResult(result, effectiveFormat), result, effectiveFormat) };
         }
         case "generate_fix_plan": {
           const plan = await generateFixPlan(validDomain, scanCacheKV, runtimeOptions);
@@ -10329,9 +10350,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatFixPlan(plan, effectiveFormat))] };
+          return { content: buildToolContent(formatFixPlan(plan, effectiveFormat), plan, effectiveFormat) };
         }
         case "generate_spf_record": {
           const includeProviders = extractIncludeProviders(validatedArgs);
@@ -10347,9 +10369,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatGeneratedRecord(record, effectiveFormat))] };
+          return { content: buildToolContent(formatGeneratedRecord(record, effectiveFormat), record, effectiveFormat) };
         }
         case "generate_dmarc_record": {
           const policy = typeof validatedArgs.policy === "string" ? validatedArgs.policy : void 0;
@@ -10366,9 +10389,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatGeneratedRecord(record, effectiveFormat))] };
+          return { content: buildToolContent(formatGeneratedRecord(record, effectiveFormat), record, effectiveFormat) };
         }
         case "generate_dkim_config": {
           const provider = typeof validatedArgs.provider === "string" ? validatedArgs.provider : void 0;
@@ -10384,9 +10408,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatGeneratedRecord(record, effectiveFormat))] };
+          return { content: buildToolContent(formatGeneratedRecord(record, effectiveFormat), record, effectiveFormat) };
         }
         case "generate_mta_sts_policy": {
           const mxHosts = extractMxHosts(validatedArgs);
@@ -10402,9 +10427,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatGeneratedRecord(record, effectiveFormat))] };
+          return { content: buildToolContent(formatGeneratedRecord(record, effectiveFormat), record, effectiveFormat) };
         }
         case "get_benchmark": {
           const profile = typeof validatedArgs.profile === "string" ? validatedArgs.profile : "mail_enabled";
@@ -10419,9 +10445,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatBenchmark(result, effectiveFormat))] };
+          return { content: buildToolContent(formatBenchmark(result, effectiveFormat), result, effectiveFormat) };
         }
         case "get_provider_insights": {
           const provider = typeof validatedArgs.provider === "string" ? validatedArgs.provider : "";
@@ -10440,9 +10467,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatProviderInsights(result, effectiveFormat))] };
+          return { content: buildToolContent(formatProviderInsights(result, effectiveFormat), result, effectiveFormat) };
         }
         case "assess_spoofability": {
           const result = await assessSpoofability(validDomain, buildDnsOptions(runtimeOptions));
@@ -10459,9 +10487,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatSpoofability(result, effectiveFormat))] };
+          return { content: buildToolContent(formatSpoofability(result, effectiveFormat), result, effectiveFormat) };
         }
         case "check_resolver_consistency": {
           const recordType = extractRecordType(validatedArgs);
@@ -10480,9 +10509,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatResolverConsistency(result, effectiveFormat))] };
+          return { content: buildToolContent(formatResolverConsistency(result, effectiveFormat), result, effectiveFormat) };
         }
         case "explain_finding": {
           let explainArgs;
@@ -10503,9 +10533,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatExplanation(result, effectiveFormat))] };
+          return { content: buildToolContent(formatExplanation(result, effectiveFormat), result, effectiveFormat) };
         }
         case "validate_fix": {
           const check = typeof validatedArgs.check === "string" ? validatedArgs.check : "";
@@ -10524,9 +10555,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatValidateFix(result, effectiveFormat))] };
+          return { content: buildToolContent(formatValidateFix(result, effectiveFormat), result, effectiveFormat) };
         }
         case "map_supply_chain": {
           const result = await mapSupplyChain(validDomain, buildDnsOptions(runtimeOptions));
@@ -10543,9 +10575,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatSupplyChain(result, effectiveFormat))] };
+          return { content: buildToolContent(formatSupplyChain(result, effectiveFormat), result, effectiveFormat) };
         }
         case "generate_rollout_plan": {
           const targetPolicy = typeof validatedArgs.target_policy === "string" ? validatedArgs.target_policy : "reject";
@@ -10564,9 +10597,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatRolloutPlan(result, effectiveFormat))] };
+          return { content: buildToolContent(formatRolloutPlan(result, effectiveFormat), result, effectiveFormat) };
         }
         case "analyze_drift": {
           const baselineStr = typeof validatedArgs.baseline === "string" ? validatedArgs.baseline : "";
@@ -10604,9 +10638,10 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatDriftReport(drift, effectiveFormat))] };
+          return { content: buildToolContent(formatDriftReport(drift, effectiveFormat), drift, effectiveFormat) };
         }
         case "resolve_spf_chain": {
           const result = await resolveSpfChain(validDomain, buildDnsOptions(runtimeOptions));
@@ -10623,30 +10658,31 @@ STRUCTURED_RESULT -->`));
             severity: "info",
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
-          return { content: [mcpText(formatSpfChain(result, effectiveFormat))] };
+          return { content: buildToolContent(formatSpfChain(result, effectiveFormat), result, effectiveFormat) };
         }
         case "discover_subdomains": {
           const result = await discoverSubdomains(validDomain, runtimeOptions?.certstream);
           logResult = `${result.totalSubdomains} subdomains`;
           logDetails = { totalSubdomains: result.totalSubdomains, issues: result.issues.length };
           logToolSuccess({ toolName: name, durationMs: Date.now() - startTime, domain, analytics: runtimeOptions?.analytics, status: "pass", logResult, logDetails, severity: "info", country: runtimeOptions?.country, clientType: runtimeOptions?.clientType, authTier: runtimeOptions?.authTier });
-          return { content: [mcpText(formatSubdomainDiscovery(result, effectiveFormat))] };
+          return { content: buildToolContent(formatSubdomainDiscovery(result, effectiveFormat), result, effectiveFormat) };
         }
         case "map_compliance": {
           const result = await mapCompliance(validDomain, scanCacheKV, runtimeOptions);
           logResult = "mapped";
           logDetails = result;
           logToolSuccess({ toolName: name, durationMs: Date.now() - startTime, domain, analytics: runtimeOptions?.analytics, status: "pass", logResult, logDetails, severity: "info", country: runtimeOptions?.country, clientType: runtimeOptions?.clientType, authTier: runtimeOptions?.authTier });
-          return { content: [mcpText(formatCompliance(result, effectiveFormat))] };
+          return { content: buildToolContent(formatCompliance(result, effectiveFormat), result, effectiveFormat) };
         }
         case "simulate_attack_paths": {
           const result = await simulateAttackPaths(validDomain, buildDnsOptions(runtimeOptions));
           logResult = `${result.totalPaths} paths, risk: ${result.overallRisk}`;
           logDetails = { totalPaths: result.totalPaths, overallRisk: result.overallRisk };
           logToolSuccess({ toolName: name, durationMs: Date.now() - startTime, domain, analytics: runtimeOptions?.analytics, status: result.overallRisk === "low" ? "pass" : "fail", logResult, logDetails, severity: "info", country: runtimeOptions?.country, clientType: runtimeOptions?.clientType, authTier: runtimeOptions?.authTier });
-          return { content: [mcpText(formatAttackPaths(result, effectiveFormat))] };
+          return { content: buildToolContent(formatAttackPaths(result, effectiveFormat), result, effectiveFormat) };
         }
         default:
           logToolFailure({
@@ -10658,7 +10694,8 @@ STRUCTURED_RESULT -->`));
             args,
             country: runtimeOptions?.country,
             clientType: runtimeOptions?.clientType,
-            authTier: runtimeOptions?.authTier
+            authTier: runtimeOptions?.authTier,
+            keyHash: runtimeOptions?.keyHash
           });
           return buildToolErrorResult(`Unknown tool: ${name}. Call tools/list to see all 44 available tools.`);
       }
@@ -10678,7 +10715,8 @@ STRUCTURED_RESULT -->`));
         args,
         country: runtimeOptions?.country,
         clientType: runtimeOptions?.clientType,
-        authTier: runtimeOptions?.authTier
+        authTier: runtimeOptions?.authTier,
+        keyHash: runtimeOptions?.keyHash
       });
       return {
         content: [mcpError(`${name} timed out after ${TOOL_CALL_TIMEOUT_MS / 1e3}s. Try a simpler check or retry \u2014 cached partial results make retries faster.`)],
@@ -10695,7 +10733,8 @@ STRUCTURED_RESULT -->`));
       args,
       country: runtimeOptions?.country,
       clientType: runtimeOptions?.clientType,
-      authTier: runtimeOptions?.authTier
+      authTier: runtimeOptions?.authTier,
+      keyHash: runtimeOptions?.keyHash
     });
     return buildToolErrorResult(message);
   }
@@ -11207,7 +11246,8 @@ async function dispatchMcpMethod(options) {
           action: "created",
           country: options.country,
           clientType: options.clientType,
-          authTier: options.authTier
+          authTier: options.authTier,
+          keyHash: options.keyHash
         });
       }
       return {
@@ -11253,6 +11293,7 @@ async function dispatchMcpMethod(options) {
         country: options.country,
         clientType: options.clientType,
         authTier: options.authTier,
+        keyHash: options.keyHash,
         certstream: options.certstream
       });
       return {
@@ -11352,7 +11393,8 @@ function emitRequestAnalytics(options, method, status, hasJsonRpcError) {
     country: options.country,
     clientType: options.clientType,
     authTier: options.authTier,
-    sessionHash: options.sessionHash
+    sessionHash: options.sessionHash,
+    keyHash: options.keyHash
   });
 }
 async function executeMcpRequest(options) {
@@ -11585,7 +11627,8 @@ async function executeMcpRequest(options) {
               method,
               country: options.country,
               clientType: options.clientType,
-              authTier: options.authTier
+              authTier: options.authTier,
+              keyHash: options.keyHash
             });
             logEvent({
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11809,7 +11852,7 @@ async function executeMcpRequest(options) {
 }
 
 // src/lib/server-version.ts
-var SERVER_VERSION = "2.3.5";
+var SERVER_VERSION = "2.6.2";
 
 // src/stdio.ts
 function buildNotInitializedError(id) {