@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/frontend/src/lib/analysis/artifact-integrity.js

@@ -1,21 +0,0 @@
-// Small environment-neutral integrity helper for deliberate local exports.
-// Inputs must already be normalized and bounded by the owning artifact model.
-export function canonicalArtifactJson(value) {
-    if (value === undefined)
-        return 'null';
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(canonicalArtifactJson).join(',')}]`;
-    const entries = Object.entries(value)
-        .filter(([, entry]) => entry !== undefined)
-        .sort(([left], [right]) => left.localeCompare(right));
-    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalArtifactJson(entry)}`).join(',')}}`;
-}
-export async function sha256ArtifactDigest(value) {
-    const bytes = new TextEncoder().encode(canonicalArtifactJson(value));
-    const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
-    return `sha256:${[...new Uint8Array(digest)]
-        .map((byte) => byte.toString(16).padStart(2, '0'))
-        .join('')}`;
-}

package/frontend/src/lib/analysis/bulk-retry-plan.js

@@ -1,79 +0,0 @@
-import { normalizeBulkSessionResult, } from "./bulk-session-model.js";
-import { limitedBulkSources } from "./bulk-source-coverage.js";
-export const MAX_BULK_RETRY_ROWS = 200;
-export const BULK_REVIEW_STALE_AFTER_DAYS = 7;
-function freshness(value, now = Date.now()) {
-    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) {
-        return { observedAt: null, ageDays: null, state: 'unknown' };
-    }
-    const observedAt = new Date(value).toISOString();
-    const ageDays = Math.max(0, Math.floor((now - Date.parse(observedAt)) / 86_400_000));
-    return {
-        observedAt,
-        ageDays,
-        state: ageDays >= BULK_REVIEW_STALE_AFTER_DAYS ? 'stale' : 'current',
-    };
-}
-function retryRow(value, isStale) {
-    const limitedSources = limitedBulkSources(value.domain, value.sourceCoverage)
-        .sort()
-        .slice(0, 12);
-    const reasons = [];
-    if (value.status === 'error')
-        reasons.push('error');
-    if (limitedSources.length)
-        reasons.push('limited_source');
-    if (isStale)
-        reasons.push('stale');
-    return reasons.length ? { domain: value.domain, reasons, limitedSources } : null;
-}
-export function buildBulkRetryPlan(values, mode, observedAtRaw = null, now = Date.now()) {
-    const observationFreshness = freshness(observedAtRaw, now);
-    const candidates = values
-        .map(normalizeBulkSessionResult)
-        .filter((value) => Boolean(value))
-        .map((value) => retryRow(value, observationFreshness.state === 'stale'))
-        .filter((value) => Boolean(value));
-    const rows = candidates.slice(0, MAX_BULK_RETRY_ROWS);
-    return {
-        mode,
-        lookupRequests: rows.length,
-        rows,
-        destinations: mode === 'deep'
-            ? ['registry RDAP', 'registrar RDAP when advertised', 'WHOIS', 'DNS resolvers', 'target HTTP(S)', 'target TLS']
-            : ['registry RDAP', 'authoritative DNS delegation when registration sources are inconclusive'],
-        capped: candidates.length > rows.length,
-        freshness: observationFreshness,
-        limitations: [
-            'This repeats the selected lookup profile; the current API does not request only one upstream source.',
-            `Evidence is marked stale after ${BULK_REVIEW_STALE_AFTER_DAYS} days for review purposes; this is a local observation age, not an upstream record age.`,
-            'Optional third-party intelligence providers are not contacted by Bulk.',
-            'Sources deliberately skipped by the selected scan profile or deployment policy do not independently trigger a retry.',
-            'A retry can remain partial or fail and does not convert unavailable evidence into absence.',
-        ],
-    };
-}
-export function preservePriorBulkResult(previousRaw, currentRaw) {
-    const previous = normalizeBulkSessionResult(previousRaw);
-    const current = normalizeBulkSessionResult(currentRaw);
-    if (!previous || !current || previous.domain !== current.domain || previous.status !== 'complete') {
-        return { preserve: false, reason: '' };
-    }
-    if (current.status === 'error') {
-        return { preserve: true, reason: 'The retry failed, so the prior settled result was retained.' };
-    }
-    if (previous.scanDepth === 'deep' && current.scanDepth === 'fast') {
-        return { preserve: true, reason: 'The retry returned only Fast evidence, so the prior Deep result was retained.' };
-    }
-    const currentSources = new Map(current.sourceCoverage.map((item) => [item.source, item.state]));
-    const regressed = previous.sourceCoverage
-        .filter((item) => item.state === 'complete')
-        .map((item) => item.source)
-        .filter((source) => currentSources.get(source) !== 'complete');
-    return regressed.length
-        ? {
-            preserve: true,
-            reason: `The retry reduced complete coverage for ${regressed.slice(0, 6).join(', ')}, so the prior settled result was retained.`,
-        }
-        : { preserve: false, reason: '' };
-}

package/frontend/src/lib/analysis/bulk-source-coverage.js

@@ -1,76 +0,0 @@
-// Authority-aware interpretation for compact Bulk source observations. Raw
-// source states remain unchanged; this layer only decides whether an observed
-// limitation was unexpected for the registry's published service paths.
-import { registryCapabilityFor } from "../../../../lib/registry-capabilities.mjs";
-const MAX_SOURCE_OBSERVATIONS = 32;
-const MAX_SOURCE_TEXT_LENGTH = 40;
-const CONTROL_RE = /[\u0000-\u001f\u007f]/u;
-const LIMITED_SOURCE_STATES = new Set([
-    'error',
-    'failed',
-    'inconclusive',
-    'partial',
-    'rate_limited',
-    'unavailable',
-    'unsupported',
-]);
-function text(value) {
-    return typeof value === 'string'
-        && value.length <= MAX_SOURCE_TEXT_LENGTH
-        && !CONTROL_RE.test(value)
-        ? value.trim().toLowerCase()
-        : '';
-}
-function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-}
-function observations(value) {
-    return Array.isArray(value)
-        ? value.slice(0, MAX_SOURCE_OBSERVATIONS).flatMap((entry) => {
-            const item = record(entry);
-            const source = text(item?.source);
-            const state = text(item?.state);
-            return source && state ? [{ source, state }] : [];
-        })
-        : [];
-}
-function expectedUnsupportedSources(domain) {
-    const capability = registryCapabilityFor(domain);
-    if (!capability)
-        return new Set();
-    const expected = new Set();
-    if (capability.rdapAccessProfile === 'no-iana-service')
-        expected.add('rdap');
-    if (capability.whoisAccessProfile === 'no-iana-service')
-        expected.add('whois');
-    return expected;
-}
-export function isExpectedUnsupportedBulkSource(domain, observation) {
-    const source = text(observation.source);
-    const state = text(observation.state);
-    return state === 'unsupported' && expectedUnsupportedSources(domain).has(source);
-}
-export function limitedBulkSources(domain, coverage) {
-    const expectedUnsupported = expectedUnsupportedSources(domain);
-    return observations(coverage)
-        .filter(({ source, state }) => (LIMITED_SOURCE_STATES.has(state)
-        && !(state === 'unsupported' && expectedUnsupported.has(source))))
-        .map(({ source }) => source);
-}
-export function classifyBulkSourceCoverage(domain, coverage) {
-    const retained = observations(coverage);
-    if (!retained.length)
-        return 'unrecorded';
-    return limitedBulkSources(domain, retained).length ? 'limited' : 'complete';
-}
-export function describeBulkSourceCoverage(domain, observation) {
-    const source = text(observation.source);
-    const state = text(observation.state);
-    if (!source || !state)
-        return 'unrecorded source';
-    return isExpectedUnsupportedBulkSource(domain, observation)
-        ? `${source}: unsupported (no IANA-published service)`
-        : `${source}: ${state}`;
-}

package/frontend/src/lib/analysis/case-migration-model.js

@@ -1,253 +0,0 @@
-import { CASE_DISPOSITIONS, CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, CASE_SOURCES, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, isoOrNull, normalizeCase, normalizeDomain, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, } from "./case-record-model.js";
-import { mergeCaseActions, mergeCaseAssertions, mergeCaseDecisions, mergeCaseEvidencePins, mergeCaseManualTrail, mergeCaseSightings, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseSightings, } from "./case-response-model.js";
-const STATUS_VALUES = new Set(CASE_STATUSES.map((item) => item.value));
-const DISPOSITION_VALUES = new Set(CASE_DISPOSITIONS.map((item) => item.value));
-const SOURCE_VALUES = new Set(CASE_SOURCES.map((item) => item.value));
-function assignUniqueIds(cases) {
-    const used = new Set();
-    for (const record of [...cases].sort((a, b) => a.domain.localeCompare(b.domain))) {
-        let id = safeId(record.id) || deterministicId(record.domain);
-        if (used.has(id)) {
-            const base = deterministicId(record.domain);
-            id = base;
-            let suffix = 2;
-            while (used.has(id))
-                id = `${base}-${suffix++}`;
-        }
-        used.add(id);
-        record.id = id;
-    }
-}
-/**
- * Recovers a clean, bounded store from an arbitrary parsed value. Accepts the
- * versioned envelope or a bare array, drops malformed records, keeps a single
- * case per domain (most recently updated wins), caps to MAX_CASES by recency,
- * and guarantees globally unique safe ids. Never throws.
- * @param {unknown} raw
- * @returns {CaseStore}
- */
-export function normalizeCaseStore(raw) {
-    const now = new Date().toISOString();
-    const byDomain = new Map();
-    for (const item of asCaseList(raw)) {
-        const normalized = normalizeCase(item, undefined, now);
-        if (!normalized)
-            continue;
-        const existing = byDomain.get(normalized.domain);
-        if (!existing || Date.parse(normalized.updatedAt) >= Date.parse(existing.updatedAt)) {
-            byDomain.set(normalized.domain, normalized);
-        }
-    }
-    const cases = [...byDomain.values()]
-        .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-        .slice(0, MAX_CASES);
-    assignUniqueIds(cases);
-    return { version: CASE_SCHEMA_VERSION, cases };
-}
-/**
- * The schema version declared by a stored/parsed value, or null. The storage
- * wrapper uses this to refuse overwriting data written by a newer, unsupported
- * version instead of silently downgrading it.
- * @param {unknown} raw
- * @returns {number | null}
- */
-export function parseStoreVersion(raw) {
-    const value = objectRecord(raw).version;
-    return typeof value === 'number' ? value : null;
-}
-/** @param {unknown} raw @returns {unknown[]} */
-function asCaseList(raw) {
-    if (Array.isArray(raw))
-        return raw;
-    const cases = objectRecord(raw).cases;
-    if (Array.isArray(cases))
-        return cases;
-    return [];
-}
-/**
- * @param {{ domain: unknown, status?: unknown, disposition?: unknown, source?: unknown, tags?: unknown, evidence?: unknown, note?: unknown }} input
- * @param {string} [nowIso]
- * @returns {CaseRecord}
- */
-function importScalar(value, valid) {
-    return typeof value === 'string' && valid.has(value) ? value : undefined;
-}
-/**
- * Validates one imported record into a patch. Unlike normalizeCase, absent or
- * invalid scalar fields stay `undefined` (never defaulted) and a missing/invalid
- * updatedAt stays `null` (treated as older than any real local timestamp), so an
- * incomplete import can never win a merge over valid local data. Imported
- * evidence is normalized additively; a snapshot with no captured time falls back
- * only to the imported record's own (older) timestamps, never to "now".
- * @param {unknown} raw
- * @returns {ImportPatch | null}
- */
-function extractImportPatch(raw) {
-    const record = objectRecord(raw);
-    const domain = normalizeDomain(record.domain);
-    if (!domain)
-        return null;
-    const importFallback = isoOrNull(record.updatedAt) || isoOrNull(record.createdAt) || null;
-    const normalizedFallback = importFallback || '1970-01-01T00:00:00.000Z';
-    const rawEvidence = Array.isArray(record.evidenceHistory) ? record.evidenceHistory : [];
-    const evidencePins = normalizeCaseEvidencePins(record.evidencePins, normalizedFallback);
-    const pinIds = new Set(evidencePins.map((item) => item.id));
-    return {
-        domain,
-        rawId: typeof record.id === 'string' ? record.id : null,
-        status: importScalar(record.status, STATUS_VALUES),
-        disposition: importScalar(record.disposition, DISPOSITION_VALUES),
-        reviewReasonCode: Object.hasOwn(record, 'reviewReasonCode')
-            ? normalizeReviewReasonCode(record.reviewReasonCode)
-            : undefined,
-        source: importScalar(record.source, SOURCE_VALUES),
-        evidenceHistory: normalizeEvidenceHistory(rawEvidence, { source: 'import', fallback: importFallback }),
-        evidencePins,
-        decisions: normalizeCaseDecisions(record.decisions, normalizedFallback, pinIds),
-        actions: normalizeCaseActions(record.actions, normalizedFallback),
-        assertions: normalizeCaseAssertions(record.assertions, normalizedFallback, pinIds),
-        manualTrail: normalizeCaseManualTrail(record.manualTrail, normalizedFallback),
-        sightings: normalizeCaseSightings(record.sightings, normalizedFallback, pinIds),
-        tags: normalizeTags(record.tags),
-        // Imported notes fall back only to the imported record's own timestamps
-        // (never "now"), so a timestamp-less note gets a stable, deterministic time
-        // and id, and re-importing the same file cannot manufacture a duplicate or a
-        // spuriously-newer note.
-        notes: normalizeNotes(record.notes, importFallback),
-        createdAt: isoOrNull(record.createdAt),
-        updatedAt: isoOrNull(record.updatedAt),
-    };
-}
-/** @param {CaseNote[]} a @param {CaseNote[]} b @returns {CaseNote[]} */
-function unionNotes(a, b) {
-    const byId = new Map();
-    for (const note of [...a, ...b]) {
-        if (!byId.has(note.id))
-            byId.set(note.id, note);
-    }
-    const notes = [...byId.values()].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
-    return notes.slice(Math.max(0, notes.length - MAX_NOTES_PER_CASE));
-}
-// Additive, deduplicated union of two evidence histories. Identical material
-// collapses (earliest firstCapturedAt, latest capturedAt), distinct snapshots
-// are retained subject to the per-case bound, and an older import can never
-// move an existing observation backwards.
-function mergeEvidenceHistories(local, imported) {
-    return normalizeEvidenceHistory([...local, ...imported], { source: 'import', fallback: null });
-}
-/** @param {ImportPatch} patch @param {string} now @returns {CaseRecord} */
-function caseFromPatch(patch, now) {
-    return {
-        id: '', // assigned by mergeCases so it can guarantee uniqueness against locals
-        domain: patch.domain,
-        status: patch.status ?? DEFAULT_STATUS,
-        disposition: patch.disposition ?? DEFAULT_DISPOSITION,
-        reviewReasonCode: patch.reviewReasonCode ?? null,
-        tags: patch.tags,
-        notes: patch.notes,
-        source: patch.source ?? DEFAULT_SOURCE,
-        evidenceHistory: patch.evidenceHistory,
-        evidencePins: patch.evidencePins,
-        decisions: patch.decisions,
-        actions: patch.actions,
-        assertions: patch.assertions,
-        manualTrail: patch.manualTrail,
-        sightings: patch.sightings,
-        createdAt: patch.createdAt || patch.updatedAt || now,
-        updatedAt: patch.updatedAt || patch.createdAt || now,
-    };
-}
-/**
- * Merges an imported patch into an existing local case. Notes, tags, and
- * evidence history are merged additively (never destructive); a scalar field is
- * only overwritten when the import provided a valid value AND is strictly newer
- * than the local record. A patch with no/invalid updatedAt is never newer.
- * @param {CaseRecord} local
- * @param {ImportPatch} patch
- * @returns {CaseRecord}
- */
-function applyImportPatch(local, patch) {
-    const importNewer = patch.updatedAt !== null && Date.parse(patch.updatedAt) > Date.parse(local.updatedAt);
-    const fallback = patch.updatedAt || local.updatedAt;
-    const evidencePins = mergeCaseEvidencePins(local.evidencePins, patch.evidencePins, fallback);
-    const pinIds = new Set(evidencePins.map((item) => item.id));
-    return {
-        ...local,
-        status: patch.status !== undefined && importNewer ? patch.status : local.status,
-        disposition: patch.disposition !== undefined && importNewer ? patch.disposition : local.disposition,
-        reviewReasonCode: patch.reviewReasonCode !== undefined && importNewer ? patch.reviewReasonCode : local.reviewReasonCode ?? null,
-        source: patch.source !== undefined && importNewer ? patch.source : local.source,
-        evidenceHistory: mergeEvidenceHistories(local.evidenceHistory, patch.evidenceHistory),
-        evidencePins,
-        decisions: mergeCaseDecisions(local.decisions, patch.decisions, fallback, pinIds),
-        actions: mergeCaseActions(local.actions, patch.actions, fallback),
-        assertions: mergeCaseAssertions(local.assertions, patch.assertions, fallback, pinIds),
-        manualTrail: mergeCaseManualTrail(local.manualTrail, patch.manualTrail, fallback),
-        sightings: mergeCaseSightings(local.sightings, patch.sightings, fallback, pinIds),
-        tags: normalizeTags([...local.tags, ...patch.tags]),
-        notes: unionNotes(local.notes, patch.notes),
-        createdAt: patch.createdAt && Date.parse(patch.createdAt) < Date.parse(local.createdAt) ? patch.createdAt : local.createdAt,
-        updatedAt: importNewer ? (patch.updatedAt ?? local.updatedAt) : local.updatedAt,
-    };
-}
-function pickFreeId(preferred, domain, used) {
-    const wanted = safeId(preferred);
-    let id = wanted && !used.has(wanted) ? wanted : deterministicId(domain);
-    const base = deterministicId(domain);
-    let suffix = 2;
-    while (used.has(id))
-        id = `${base}-${suffix++}`;
-    return id;
-}
-/**
- * Merges an imported (already parsed) value into the local cases. Predictable
- * and idempotent: unknown records are skipped, existing domains merge without
- * losing newer local decisions, and new ones are added until the store bound is
- * reached. An imported envelope that declares a schema version newer than we
- * support is rejected up front (before any local data is touched) rather than
- * reinterpreted.
- * @param {CaseRecord[]} localCases
- * @param {unknown} importedRaw
- * @returns {{ cases: CaseRecord[], added: number, updated: number, skipped: number }}
- */
-export function mergeCases(localCases, importedRaw) {
-    const importedVersion = parseStoreVersion(importedRaw);
-    if (importedVersion !== null && Number.isInteger(importedVersion) && importedVersion > CASE_SCHEMA_VERSION) {
-        throw new Error(`This case file was exported by a newer version of WHOISleuth (schema ${importedVersion}). Update the app before importing it.`);
-    }
-    if (!CASE_IMPORT_VERSIONS.includes(importedVersion)
-        || !importedRaw || typeof importedRaw !== 'object'
-        || !Array.isArray(objectRecord(importedRaw).cases)) {
-        throw new Error(`Expected a WHOISleuth case export using schema ${CASE_IMPORT_VERSIONS.join(' or ')}.`);
-    }
-    const local = normalizeCaseStore(localCases).cases;
-    const byDomain = new Map(local.map((item) => [item.domain, item]));
-    const usedIds = new Set(local.map((item) => item.id));
-    let added = 0;
-    let updated = 0;
-    let skipped = 0;
-    const now = new Date().toISOString();
-    for (const item of asCaseList(importedRaw)) {
-        const patch = extractImportPatch(item);
-        if (!patch) {
-            skipped += 1;
-            continue;
-        }
-        const existing = byDomain.get(patch.domain);
-        if (existing) {
-            byDomain.set(patch.domain, applyImportPatch(existing, patch));
-            updated += 1;
-        }
-        else if (byDomain.size < MAX_CASES) {
-            const record = caseFromPatch(patch, now);
-            record.id = pickFreeId(patch.rawId, patch.domain, usedIds);
-            usedIds.add(record.id);
-            byDomain.set(patch.domain, record);
-            added += 1;
-        }
-        else {
-            skipped += 1;
-        }
-    }
-    return { cases: normalizeCaseStore([...byDomain.values()]).cases, added, updated, skipped };
-}

package/frontend/src/lib/analysis/case-record-model.js

@@ -1,7 +0,0 @@
-// Stable case-record facade. Core validation, evidence history/comparison,
-// and analyst-record operations remain framework-neutral and independently
-// testable while existing consumers keep one compatibility import.
-export * from "./case-record-contracts.js";
-export * from "./case-record-core.js";
-export * from "./case-evidence-model.js";
-export * from "./case-record-operations.js";