@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/cli/source-reliability.mjs

@@ -1,5 +1,9 @@
 import { Buffer } from 'node:buffer';
-import { canonicalArtifactJson } from "../frontend/src/lib/analysis/artifact-integrity.js";
+import { canonicalArtifactJson } from "../packages/evidence/artifact-integrity.mjs";
+import { scanBoundedJson } from "../lib/bounded-json.mjs";
+import { normalizeExplicitIsoTimestamp, normalizeLegacyIsoTimestamp, } from "../packages/evidence/observation.mjs";
+import { CLI_LOOKUP_SCHEMA, MAX_CLI_LOOKUP_BYTES, } from "../packages/contracts/cli-lookup.mjs";
+import { normalizeCliLookupDocument } from "./saved-lookup.mjs";
 export const SOURCE_RELIABILITY_REPORT_SCHEMA = 'whoisleuth.source-reliability-report';
 export const SOURCE_RELIABILITY_REPORT_VERSION = 1;
 export const MAX_SOURCE_RELIABILITY_INPUT_BYTES = 12 * 1024 * 1024;
@@ -22,7 +26,7 @@ const STATES = new Set([
     'stale',
 ]);
 const LOOKUP_SCHEMAS = new Set([
-    'whoisleuth.cli.lookup',
+    CLI_LOOKUP_SCHEMA,
     'whoisleuth.cli.bulk',
     'whoisleuth.cli.bulk.item',
 ]);
@@ -134,10 +138,11 @@ function parseValues(raw) {
     }
     let parsed;
     try {
+        scanBoundedJson(raw);
         parsed = JSON.parse(raw);
     }
     catch {
-        throw new TypeError('Source reliability input must be valid JSON.');
+        throw new TypeError('Source reliability input must be valid bounded JSON without duplicate keys.');
     }
     const values = Array.isArray(parsed) ? parsed : [parsed];
     if (values.length === 0 || values.length > MAX_SOURCE_RELIABILITY_DOCUMENTS) {
@@ -150,10 +155,29 @@ function parseValues(raw) {
         return document;
     });
 }
+function hasJsonArrayEnvelope(raw) {
+    for (let index = 0; index < raw.length; index += 1) {
+        const code = raw.charCodeAt(index);
+        if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d)
+            continue;
+        return code === 0x5b;
+    }
+    return false;
+}
 function parseLookupDocuments(values) {
     return values.map((document) => {
-        if (!LOOKUP_SCHEMAS.has(String(document.schema)) || document.version !== 1) {
-            throw new TypeError('Source reliability input requires only version 1 CLI lookup, Bulk, or Bulk-item documents, or only source reliability reports.');
+        const schema = String(document.schema);
+        if (schema === CLI_LOOKUP_SCHEMA) {
+            try {
+                return normalizeCliLookupDocument(document, { label: 'Source reliability Lookup input' });
+            }
+            catch {
+                throw new TypeError('Source reliability input requires a supported bounded CLI Lookup document.');
+            }
+        }
+        const supported = document.version === 1;
+        if (!LOOKUP_SCHEMAS.has(schema) || !supported) {
+            throw new TypeError('Source reliability input requires CLI Lookup version 1 or 2, version 1 Bulk or Bulk-item documents, or only source reliability reports.');
         }
         return document;
     });
@@ -162,8 +186,9 @@ function accumulator(store, source) {
     const existing = store.get(source);
     if (existing)
         return existing;
-    if (store.size >= MAX_SOURCE_RELIABILITY_SOURCES)
-        return null;
+    if (store.size >= MAX_SOURCE_RELIABILITY_SOURCES) {
+        throw new TypeError(`Source reliability input exceeds the ${MAX_SOURCE_RELIABILITY_SOURCES}-source limit.`);
+    }
     const created = {
         states: new Map(),
         observationDurations: [],
@@ -183,8 +208,6 @@ function accumulator(store, source) {
 }
 function addState(store, source, state) {
     const item = accumulator(store, source);
-    if (!item)
-        return;
     item.states.set(state, (item.states.get(state) ?? 0) + 1);
     if (state === 'rate_limited')
         item.rateLimited += 1;
@@ -194,15 +217,16 @@ function collectTiming(document, store) {
     const timing = record(diagnostics?.timing);
     if (timing?.version !== 1 || !Array.isArray(timing.sources))
         return;
-    for (const rawEntry of timing.sources.slice(0, 16)) {
+    if (timing.sources.length > 16) {
+        throw new TypeError('Source reliability input exceeds the 16-source timing limit.');
+    }
+    for (const rawEntry of timing.sources) {
         const entry = record(rawEntry);
         const source = safeSource(entry?.source);
         const duration = boundedDuration(entry?.durationMs);
         if (!source || !TIMING_SOURCES.has(source) || duration === null)
             continue;
         const item = accumulator(store, source);
-        if (!item)
-            continue;
         item.timingDurations.push(duration);
         item.timingSamples += 1;
     }
@@ -239,8 +263,6 @@ function collectObservation(value, store) {
     if (!source || !state)
         return;
     const item = accumulator(store, source);
-    if (!item)
-        return;
     item.observationSamples += 1;
     addState(store, source, state);
     const duration = boundedDuration(value.durationMs);
@@ -254,8 +276,14 @@ function traverse(document, store) {
     const stack = [{ value: document, depth: 0 }];
     while (stack.length) {
         const current = stack.pop();
-        if (!current || current.depth > 12 || visited >= MAX_SOURCE_RELIABILITY_TRAVERSAL_NODES)
+        if (!current)
             continue;
+        if (current.depth > 12) {
+            throw new TypeError('Source reliability input exceeds the 12-level traversal limit.');
+        }
+        if (visited >= MAX_SOURCE_RELIABILITY_TRAVERSAL_NODES) {
+            throw new TypeError(`Source reliability input exceeds the ${MAX_SOURCE_RELIABILITY_TRAVERSAL_NODES}-node traversal limit.`);
+        }
         visited += 1;
         const object = record(current.value);
         if (object) {
@@ -267,13 +295,20 @@ function traverse(document, store) {
                 if (source)
                     addState(store, source, 'rate_limited');
             }
-            for (const child of Object.values(object).slice(0, 200)) {
+            const children = Object.values(object);
+            if (children.length > 200) {
+                throw new TypeError('Source reliability input contains an object with more than 200 fields.');
+            }
+            for (const child of children) {
                 if (child && typeof child === 'object')
                     stack.push({ value: child, depth: current.depth + 1 });
             }
         }
         else if (Array.isArray(current.value)) {
-            for (const child of current.value.slice(0, 1_000)) {
+            if (current.value.length > 1_000) {
+                throw new TypeError('Source reliability input contains an array with more than 1000 items.');
+            }
+            for (const child of current.value) {
                 if (child && typeof child === 'object')
                     stack.push({ value: child, depth: current.depth + 1 });
             }
@@ -298,13 +333,19 @@ function ratio(numerator, denominator) {
     return denominator > 0 ? Number((numerator / denominator).toFixed(4)) : null;
 }
 function reportTimestamp(value) {
-    if (typeof value !== 'string' || value.length > 64) {
+    const normalized = normalizeExplicitIsoTimestamp(value);
+    if (!normalized) {
         throw new TypeError('Source reliability report has an invalid generation time.');
     }
-    const parsed = Date.parse(value);
-    if (!Number.isFinite(parsed))
-        throw new TypeError('Source reliability report has an invalid generation time.');
-    return new Date(parsed).toISOString();
+    return normalized;
+}
+function lookupDocumentTimestamp(document) {
+    const explicit = normalizeExplicitIsoTimestamp(document.generatedAt);
+    if (explicit)
+        return explicit;
+    return document.version === 1
+        ? normalizeLegacyIsoTimestamp(document.generatedAt)
+        : null;
 }
 function optionalReportTimestamp(value, label) {
     if (value === null)
@@ -475,8 +516,6 @@ function collectReport(report, store) {
         for (const value of Object.values(durationTrend))
             reportedDurationPoint(value);
         const item = accumulator(store, source);
-        if (!item)
-            throw new TypeError('Source reliability report exceeds the source limit.');
         const observationSamples = safeCount(samples.observations, `${source} observation sample count`);
         const timingSamples = safeCount(samples.timing, `${source} timing sample count`);
         const truncationCount = safeCount(sourceRecord.truncationCount, `${source} truncation count`);
@@ -583,9 +622,14 @@ function collectReport(report, store) {
     };
 }
 export function buildSourceReliabilityReport(raw, generatedAt = new Date().toISOString()) {
-    const timestamp = Date.parse(generatedAt);
-    if (!Number.isFinite(timestamp))
-        throw new TypeError('Source reliability report time must be valid.');
+    const normalizedGeneratedAt = normalizeExplicitIsoTimestamp(generatedAt);
+    if (!normalizedGeneratedAt)
+        throw new TypeError('Source reliability report time must use an explicit timezone.');
+    if (typeof raw === 'string'
+        && !hasJsonArrayEnvelope(raw)
+        && Buffer.byteLength(raw, 'utf8') > MAX_CLI_LOOKUP_BYTES) {
+        throw new TypeError('Source reliability input requires a supported bounded CLI Lookup document.');
+    }
     const values = parseValues(raw);
     const store = new Map();
     const reportInputs = values.every((value) => value.schema === SOURCE_RELIABILITY_REPORT_SCHEMA);
@@ -616,14 +660,9 @@ export function buildSourceReliabilityReport(raw, generatedAt = new Date().toISO
         for (const document of documents) {
             const mode = document.mode === 'fast' || document.mode === 'deep' ? document.mode : 'unknown';
             lookupModes[mode] += 1;
-            if (typeof document.generatedAt === 'string') {
-                try {
-                    sampleDates.push(reportTimestamp(document.generatedAt));
-                }
-                catch {
-                    // Invalid or missing document dates remain unmeasured.
-                }
-            }
+            const sampleDate = lookupDocumentTimestamp(document);
+            if (sampleDate)
+                sampleDates.push(sampleDate);
             traverse(document, store);
         }
     }
@@ -669,7 +708,7 @@ export function buildSourceReliabilityReport(raw, generatedAt = new Date().toISO
     return Object.freeze({
         schema: SOURCE_RELIABILITY_REPORT_SCHEMA,
         version: SOURCE_RELIABILITY_REPORT_VERSION,
-        generatedAt: new Date(timestamp).toISOString(),
+        generatedAt: normalizedGeneratedAt,
         mode: 'offline_local',
         reportsMerged,
         documentsReviewed,

package/cli/terminal-presentation.mjs

@@ -2,20 +2,40 @@ const MIN_TERMINAL_WIDTH = 40;
 const MAX_TERMINAL_WIDTH = 160;
 const DEFAULT_TERMINAL_WIDTH = 100;
 const ANSI_RESET = '\u001b[0m';
-const ANSI_BY_TONE = Object.freeze({
-    accent: '\u001b[1;36m',
-    danger: '\u001b[31m',
-    dim: '\u001b[2m',
-    info: '\u001b[36m',
-    success: '\u001b[32m',
-    warning: '\u001b[33m',
+const ANSI_BY_PALETTE = Object.freeze({
+    auto: Object.freeze({
+        accent: '\u001b[1;36m',
+        danger: '\u001b[31m',
+        dim: '\u001b[2m',
+        info: '\u001b[36m',
+        success: '\u001b[32m',
+        warning: '\u001b[33m',
+    }),
+    light: Object.freeze({
+        accent: '\u001b[1;34m',
+        danger: '\u001b[31m',
+        dim: '\u001b[2;30m',
+        info: '\u001b[34m',
+        success: '\u001b[32m',
+        warning: '\u001b[33m',
+    }),
+    dark: Object.freeze({
+        accent: '\u001b[1;96m',
+        danger: '\u001b[91m',
+        dim: '\u001b[2m',
+        info: '\u001b[96m',
+        success: '\u001b[92m',
+        warning: '\u001b[93m',
+    }),
 });
 const SECTION_LABELS = new Set([
     'Collection',
+    'DNS',
     'Discover',
     'Integrity and calibration',
     'Investigate',
     'Network',
+    'Mail',
     'Quick start',
     'Registration',
     'Result',
@@ -24,6 +44,7 @@ const SECTION_LABELS = new Set([
     'Source health',
     'Target',
     'Terminal',
+    'TLS and certificate',
     'Website and security',
 ]);
 function boundedTerminalWidth(value) {
@@ -32,7 +53,7 @@ function boundedTerminalWidth(value) {
         return DEFAULT_TERMINAL_WIDTH;
     return Math.max(MIN_TERMINAL_WIDTH, Math.min(MAX_TERMINAL_WIDTH, width));
 }
-function terminalPresentation(stream, requestedColor = true, environment = process.env) {
+function terminalPresentation(stream, requestedColor = true, environment = process.env, palette = 'auto') {
     const interactive = stream?.isTTY === true
         && environment.TERM !== 'dumb'
         && !environment.CI;
@@ -42,11 +63,15 @@ function terminalPresentation(stream, requestedColor = true, environment = proce
     return Object.freeze({
         color,
         interactive,
+        palette,
         width: interactive ? boundedTerminalWidth(stream?.columns) : null,
     });
 }
-function tone(value, selectedTone, enabled) {
-    return enabled ? `${ANSI_BY_TONE[selectedTone]}${value}${ANSI_RESET}` : value;
+function tone(value, selectedTone, presentation) {
+    if (presentation === false)
+        return value;
+    const palette = presentation === true ? 'auto' : presentation;
+    return `${ANSI_BY_PALETTE[palette][selectedTone]}${value}${ANSI_RESET}`;
 }
 function statusTone(value) {
     const normalized = value.trim().toLowerCase();
@@ -107,32 +132,32 @@ function wrapTerminalOutput(value, width) {
     const lines = value.replace(/\n$/u, '').split('\n').flatMap((line) => wrapLine(line, width));
     return `${lines.join('\n')}${trailingNewline ? '\n' : ''}`;
 }
-function colorizeLine(line) {
+function colorizeLine(line, palette) {
     const trimmed = line.trim();
     if (!trimmed)
         return line;
     const section = trimmed.endsWith(':') ? trimmed.slice(0, -1) : trimmed;
     if (SECTION_LABELS.has(section)) {
         const prefixLength = line.indexOf(trimmed);
-        return `${line.slice(0, prefixLength)}${tone(trimmed, 'accent', true)}${line.slice(prefixLength + trimmed.length)}`;
+        return `${line.slice(0, prefixLength)}${tone(trimmed, 'accent', palette)}${line.slice(prefixLength + trimmed.length)}`;
     }
     if (trimmed.startsWith('✓'))
-        return line.replace('✓', tone('✓', 'success', true));
+        return line.replace('✓', tone('✓', 'success', palette));
     if (trimmed.startsWith('!'))
-        return line.replace('!', tone('!', 'danger', true));
+        return line.replace('!', tone('!', 'danger', palette));
     if (/^(?:Limitation|Access note|Boundary)\s{2,}/u.test(trimmed)) {
-        return tone(line, 'dim', true);
+        return tone(line, 'dim', palette);
     }
     const bracket = line.match(/^(\s*)\[([^\]]+)\](.*)$/u);
     if (bracket) {
         const selectedTone = statusTone(bracket[2] || '') || 'info';
-        return `${bracket[1]}${tone(`[${bracket[2]}]`, selectedTone, true)}${bracket[3]}`;
+        return `${bracket[1]}${tone(`[${bracket[2]}]`, selectedTone, palette)}${bracket[3]}`;
     }
     const keyValue = line.match(/^(\s*)(\S(?:.*?\S)?)(\s{2,})(\S.*)$/u);
     if (keyValue) {
         const value = keyValue[4] || '';
         const selectedTone = statusTone(value);
-        return `${keyValue[1]}${tone(keyValue[2] || '', 'info', true)}${keyValue[3]}${selectedTone ? tone(value, selectedTone, true) : value}`;
+        return `${keyValue[1]}${tone(keyValue[2] || '', 'info', palette)}${keyValue[3]}${selectedTone ? tone(value, selectedTone, palette) : value}`;
     }
     return line;
 }
@@ -141,7 +166,7 @@ function presentTerminalOutput(value, presentation) {
     if (!presentation.color)
         return wrapped;
     const trailingNewline = wrapped.endsWith('\n');
-    const lines = wrapped.replace(/\n$/u, '').split('\n').map(colorizeLine);
+    const lines = wrapped.replace(/\n$/u, '').split('\n').map((line) => colorizeLine(line, presentation.palette));
     return `${lines.join('\n')}${trailingNewline ? '\n' : ''}`;
 }
 export { presentTerminalOutput, terminalPresentation, tone, wrapTerminalOutput, };