@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/frontend/src/lib/analysis/lookup-presentation.js

@@ -1,58 +0,0 @@
-export const LOOKUP_PRESENTATION_STORAGE_KEY = 'whoisleuth:lookup-presentation:v1';
-export const MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES = 1_024;
-export const LOOKUP_TASK_VIEWS = Object.freeze([
-    Object.freeze({ id: 'general', label: 'General investigation' }),
-    Object.freeze({ id: 'acquisition', label: 'Acquisition review' }),
-    Object.freeze({ id: 'brand', label: 'Brand review' }),
-    Object.freeze({ id: 'incident', label: 'Incident response' }),
-    Object.freeze({ id: 'owned', label: 'Owned-domain posture' }),
-]);
-const TASKS = new Set(LOOKUP_TASK_VIEWS.map((option) => option.id));
-export function normalizeLookupTaskView(value) {
-    return typeof value === 'string' && TASKS.has(value)
-        ? value
-        : 'general';
-}
-export function readLookupPresentation(storage) {
-    try {
-        const serialized = storage.getItem(LOOKUP_PRESENTATION_STORAGE_KEY);
-        if (serialized === null
-            || serialized.length > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES
-            || new TextEncoder().encode(serialized).byteLength > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES) {
-            return { task: 'general' };
-        }
-        const stored = JSON.parse(serialized);
-        if (stored?.version === 1) {
-            return {
-                task: normalizeLookupTaskView(stored.task),
-            };
-        }
-    }
-    catch {
-        // Invalid or unavailable browser storage falls back to the stable defaults.
-    }
-    return { task: 'general' };
-}
-export function writeLookupPresentation(storage, state) {
-    try {
-        storage.setItem(LOOKUP_PRESENTATION_STORAGE_KEY, JSON.stringify({
-            version: 1,
-            task: normalizeLookupTaskView(state.task),
-        }));
-    }
-    catch {
-        // The caller's in-memory selection remains valid when storage is unavailable.
-    }
-}
-const PRIORITY = Object.freeze({
-    general: Object.freeze(['overview', 'registry', 'web-evidence', 'relationships-history', 'source-quality', 'case-response', 'advanced-evidence']),
-    acquisition: Object.freeze(['overview', 'registry', 'relationships-history', 'web-evidence', 'source-quality', 'case-response', 'advanced-evidence']),
-    brand: Object.freeze(['overview', 'web-evidence', 'relationships-history', 'registry', 'source-quality', 'case-response', 'advanced-evidence']),
-    incident: Object.freeze(['overview', 'web-evidence', 'relationships-history', 'advanced-evidence', 'registry', 'source-quality', 'case-response']),
-    owned: Object.freeze(['overview', 'registry', 'web-evidence', 'relationships-history', 'source-quality', 'case-response', 'advanced-evidence']),
-});
-export function prioritizeLookupSectionLinks(links, task) {
-    const order = PRIORITY[normalizeLookupTaskView(task)];
-    const rank = new Map(order.map((id, index) => [`#${id}`, index]));
-    return [...links].sort((left, right) => ((rank.get(left.href) ?? order.length) - (rank.get(right.href) ?? order.length)));
-}

package/frontend/src/lib/analysis/lookup-response.js

@@ -1,2 +0,0 @@
-// Environment-neutral Lookup response contract shared with the backend.
-export * from "../../../../lib/lookup-response-contract.mjs";

package/frontend/src/lib/analysis/lookup-source-refresh.js

@@ -1,277 +0,0 @@
-import { BoundedJsonResponseError, requestJsonCapped, } from "../bounded-json-response.js";
-export const LOOKUP_SOURCE_REFRESH_VERSION = 1;
-export const LOOKUP_SOURCE_STALE_AFTER_DAYS = 7;
-export const LOOKUP_FRESHNESS_POLICY_VERSION = 1;
-export const LOOKUP_SOURCE_REFRESH_TIMEOUT_MS = 40_000;
-export const MAX_LOOKUP_SOURCE_REFRESH_KEYS = 512;
-export const MAX_LOOKUP_SOURCE_REFRESH_BYTES = 2 * 1024 * 1024;
-export const MAX_LOOKUP_SOURCE_REFRESH_HISTORY = 12;
-const DOMAIN_EVIDENCE_IDS = new Set([
-    'availability',
-    'client-behavior',
-    'dns',
-    'http',
-    'page-identity',
-    'page-role',
-    'security-posture',
-    'technology',
-    'tls',
-]);
-const NETWORK_EVIDENCE_IDS = new Set(['availability', 'dns', 'reverse-dns', 'network-context']);
-const WEB_EVIDENCE_IDS = new Set(['http', 'tls', 'page-identity', 'page-role', 'client-behavior', 'security-posture', 'technology']);
-const TASK_FRESHNESS_THRESHOLDS = Object.freeze({
-    general: Object.freeze({ registration: 30, network: 7, web: 3 }),
-    acquisition: Object.freeze({ registration: 7, network: 3, web: 3 }),
-    brand: Object.freeze({ registration: 30, network: 3, web: 1 }),
-    incident: Object.freeze({ registration: 14, network: 1, web: 1 }),
-    owned: Object.freeze({ registration: 30, network: 7, web: 3 }),
-});
-function freshnessDays(value, fallback) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? Math.max(1, Math.min(365, Math.round(parsed))) : fallback;
-}
-export function buildLookupFreshnessPolicy(task, input) {
-    const defaults = TASK_FRESHNESS_THRESHOLDS[task];
-    const custom = input?.id === 'analyst-custom';
-    return {
-        version: LOOKUP_FRESHNESS_POLICY_VERSION,
-        id: custom ? 'analyst-custom' : 'task-default',
-        task,
-        thresholdsDays: custom ? {
-            registration: freshnessDays(input?.thresholdsDays?.registration, defaults.registration),
-            network: freshnessDays(input?.thresholdsDays?.network, defaults.network),
-            web: freshnessDays(input?.thresholdsDays?.web, defaults.web),
-        } : { ...defaults },
-    };
-}
-function observedAgeDays(observedAt, now) {
-    if (typeof observedAt !== 'string' || typeof now !== 'string')
-        return null;
-    const observedMs = Date.parse(observedAt);
-    const nowMs = Date.parse(now);
-    if (!Number.isFinite(observedMs) || !Number.isFinite(nowMs))
-        return null;
-    return Math.max(0, Math.floor((nowMs - observedMs) / 86_400_000));
-}
-function limited(entries, ids) {
-    return entries.some((entry) => ids.has(entry.id) && entry.manualReviewSuggested);
-}
-function availableIds(entries, ids) {
-    return entries.filter((entry) => ids.has(entry.id)).map((entry) => entry.id).slice(0, 12);
-}
-export function buildLookupSourceRefreshPlan(ledger, observedAt, now = new Date().toISOString(), options = {}) {
-    const ageDays = observedAgeDays(observedAt, now);
-    const freshnessPolicy = buildLookupFreshnessPolicy(options.task ?? 'general', options.freshnessPolicy);
-    const entries = ledger.entries.slice(0, 24);
-    const plans = [];
-    const groups = [
-        {
-            id: 'rdap',
-            label: 'Registry RDAP',
-            endpoint: '/api/rdap',
-            ids: new Set(['rdap']),
-            disclosure: 'Starts one bounded registry RDAP operation for this target.',
-            threshold: 'registration',
-        },
-        {
-            id: 'whois',
-            label: 'WHOIS',
-            endpoint: '/api/whois',
-            ids: new Set(['whois']),
-            disclosure: 'Starts one bounded referral-aware WHOIS operation for this target.',
-            threshold: 'registration',
-        },
-        {
-            id: 'availability',
-            label: 'Domain evidence',
-            endpoint: '/api/availability',
-            ids: DOMAIN_EVIDENCE_IDS,
-            disclosure: 'Repeats the bounded domain-evidence branch, including eligible DNS, HTTP, page, and TLS work for the selected depth.',
-            threshold: 'network',
-        },
-    ];
-    for (const group of groups) {
-        const evidenceIds = availableIds(entries, group.ids);
-        if (!evidenceIds.length)
-            continue;
-        const isLimited = limited(entries, group.ids);
-        const thresholds = evidenceIds.map((id) => WEB_EVIDENCE_IDS.has(id)
-            ? freshnessPolicy.thresholdsDays.web
-            : NETWORK_EVIDENCE_IDS.has(id)
-                ? freshnessPolicy.thresholdsDays.network
-                : freshnessPolicy.thresholdsDays[group.threshold]);
-        const staleAfterDays = Math.min(...thresholds);
-        const evidenceAges = evidenceIds
-            .map((id) => observedAgeDays(options.observedAtByEvidence?.[id] ?? observedAt, now))
-            .filter((value) => value !== null);
-        const groupAgeDays = evidenceAges.length ? Math.max(...evidenceAges) : ageDays;
-        const groupStale = groupAgeDays !== null && groupAgeDays >= staleAfterDays;
-        if (!isLimited && !groupStale)
-            continue;
-        plans.push({
-            id: group.id,
-            label: group.label,
-            endpoint: group.endpoint,
-            evidenceIds,
-            reason: isLimited ? 'limited' : 'stale',
-            requestDisclosure: group.disclosure,
-            supersedesObservedAt: typeof observedAt === 'string' && Number.isFinite(Date.parse(observedAt))
-                ? new Date(observedAt).toISOString()
-                : null,
-            ageDays: groupAgeDays,
-            staleAfterDays,
-        });
-    }
-    const stale = plans.some((item) => item.reason === 'stale');
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        stale,
-        ageDays,
-        freshnessPolicy,
-        items: plans,
-        limitations: [
-            'A source refresh is displayed separately and never merged into the original unified Lookup envelope.',
-            'Run a complete Lookup before saving, comparing, or exporting replacement evidence collected at one review time.',
-            'A retry can remain partial or unavailable and never proves that missing evidence is absent.',
-            'Freshness thresholds organise review only. They do not make an older observation false or a newer observation complete.',
-        ],
-    };
-}
-function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function text(value, maximum = 180) {
-    return String(value ?? '')
-        .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, maximum);
-}
-function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
-    const base = {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        id: plan.id,
-        observedAt,
-        attemptedAt: observedAt,
-        reason: plan.reason,
-        evidenceIds: plan.evidenceIds.slice(0, 12),
-        supersedesObservedAt,
-    };
-    if (plan.id === 'rdap') {
-        const upstreamStatus = Number(body.upstreamStatus);
-        const parsed = record(body.parsed);
-        const complete = upstreamStatus === 200 && Object.keys(parsed).length > 0;
-        return {
-            ...base,
-            state: complete ? 'complete' : 'limited',
-            detail: complete
-                ? `Registry RDAP returned a validated ${upstreamStatus} response.`
-                : `Registry RDAP returned ${Number.isFinite(upstreamStatus) ? `HTTP ${upstreamStatus}` : 'no complete structured record'}.`,
-        };
-    }
-    if (plan.id === 'whois') {
-        const chain = Array.isArray(body.chain) ? body.chain : [];
-        const chainStatus = text(record(body.parsed).chainStatus, 40);
-        const complete = chain.length > 0 && chainStatus === 'complete';
-        return {
-            ...base,
-            state: complete ? 'complete' : 'limited',
-            detail: complete
-                ? `WHOIS returned a complete ${chain.length}-hop referral chain.`
-                : `WHOIS returned ${chain.length} hop${chain.length === 1 ? '' : 's'} with ${chainStatus || 'unknown'} chain status.`,
-        };
-    }
-    const state = text(body.state, 40) || 'unknown';
-    const complete = body.deepScanComplete === true
-        || (depth === 'fast' && state !== 'unknown');
-    const sourceStates = ['dns', 'http', 'tls']
-        .map((key) => text(record(body[key]).status, 40))
-        .filter(Boolean);
-    return {
-        ...base,
-        state: complete ? 'complete' : 'limited',
-        detail: `Domain evidence returned ${state}${sourceStates.length ? `; DNS, HTTP, and TLS states: ${sourceStates.join(', ')}` : ''}.`,
-    };
-}
-function unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, detail) {
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        id: plan.id,
-        state: 'unavailable',
-        detail,
-        observedAt: null,
-        attemptedAt,
-        reason: plan.reason,
-        evidenceIds: plan.evidenceIds.slice(0, 12),
-        supersedesObservedAt,
-    };
-}
-export async function requestLookupSourceRefresh(plan, query, depth, options = {}) {
-    const normalizedQuery = text(query, 4096);
-    if (!normalizedQuery)
-        return { ok: false, message: 'A valid Lookup target is required.' };
-    const timeoutMs = Number.isFinite(options.timeoutMs)
-        ? Math.max(1, Math.min(LOOKUP_SOURCE_REFRESH_TIMEOUT_MS, Math.round(Number(options.timeoutMs))))
-        : LOOKUP_SOURCE_REFRESH_TIMEOUT_MS;
-    const attemptedAt = options.now?.() ?? new Date().toISOString();
-    const supersedesObservedAt = options.supersedesObservedAt === undefined
-        ? plan.supersedesObservedAt
-        : options.supersedesObservedAt;
-    try {
-        const url = `${plan.endpoint}?q=${encodeURIComponent(normalizedQuery)}${plan.id === 'availability' && depth === 'fast' ? '&fast=true' : ''}`;
-        const { response, body: rawBody } = await requestJsonCapped(url, {
-            credentials: 'same-origin',
-        }, {
-            ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
-            maximumBytes: MAX_LOOKUP_SOURCE_REFRESH_BYTES,
-            timeoutMs,
-        });
-        const body = record(rawBody);
-        if (!response.ok) {
-            return {
-                ok: true,
-                value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, text(body.error, 240) || `The source returned HTTP ${response.status}; no new observation was recorded.`),
-            };
-        }
-        if (Object.keys(body).length > MAX_LOOKUP_SOURCE_REFRESH_KEYS) {
-            return { ok: false, message: 'Source refresh returned an oversized record.' };
-        }
-        return {
-            ok: true,
-            value: summarizeSource(plan, body, attemptedAt, depth, supersedesObservedAt),
-        };
-    }
-    catch (cause) {
-        if (cause instanceof BoundedJsonResponseError && cause.code === 'response_too_large') {
-            return { ok: true, value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, 'The source response exceeded the local limit; no new observation was recorded.') };
-        }
-        return {
-            ok: true,
-            value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, cause instanceof BoundedJsonResponseError && cause.code === 'timeout'
-                ? 'The source refresh timed out; no new observation was recorded.'
-                : 'The source refresh could not be completed; no new observation was recorded.'),
-        };
-    }
-}
-export function mergeLookupSourceRefreshLedger(current, result) {
-    const candidates = [
-        ...(current?.version === LOOKUP_SOURCE_REFRESH_VERSION ? current.entries : []),
-        result,
-    ];
-    const byObservation = new Map();
-    for (const entry of candidates.slice(-MAX_LOOKUP_SOURCE_REFRESH_HISTORY * 4)) {
-        byObservation.set(`${entry.id}:${entry.attemptedAt}`, entry);
-    }
-    const ordered = [...byObservation.values()]
-        .sort((left, right) => Date.parse(left.attemptedAt) - Date.parse(right.attemptedAt));
-    const truncated = Boolean(current?.truncated)
-        || ordered.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY
-        || candidates.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY;
-    return {
-        version: LOOKUP_SOURCE_REFRESH_VERSION,
-        entries: ordered.slice(-MAX_LOOKUP_SOURCE_REFRESH_HISTORY),
-        truncated,
-    };
-}