@eightmedia/flightcheck 0.0.0-stage → 1.0.0

package/dist/checks/agent-ready.js

@@ -0,0 +1,219 @@
+import { issue } from "./issues.js";
+import { DEFAULT_USER_AGENT } from "../crawler/defaults.js";
+/** AI crawler user-agents commonly expected in robots.txt (isitagentready / IETF drafts). */
+export const AI_BOT_USER_AGENTS = [
+    "GPTBot",
+    "OAI-SearchBot",
+    "ChatGPT-User",
+    "ClaudeBot",
+    "Claude-Web",
+    "anthropic-ai",
+    "Google-Extended",
+    "Amazonbot",
+    "Applebot-Extended",
+    "Bytespider",
+    "CCBot",
+    "PerplexityBot",
+];
+/** Link relation types useful for agent discovery (RFC 8288 / RFC 9727). */
+export const AGENT_LINK_RELS = ["api-catalog", "service-desc", "service-doc", "describedby"];
+function isSuccessfulStatus(status) {
+    return typeof status === "number" && status >= 200 && status < 300;
+}
+function looksLikeHtml(body, contentType) {
+    const type = (contentType ?? "").toLowerCase();
+    if (type.includes("text/html") || type.includes("application/xhtml"))
+        return true;
+    if (!body)
+        return false;
+    const trimmed = body.trimStart().slice(0, 200).toLowerCase();
+    return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html");
+}
+function extractContentSignals(body) {
+    const signals = [];
+    for (const line of body.split("\n")) {
+        const match = line.match(/^\s*content-signal:\s*(.+)\s*$/i);
+        if (match)
+            signals.push(match[1].trim());
+    }
+    return signals;
+}
+function extractAiBotUserAgents(body) {
+    const found = new Set();
+    for (const bot of AI_BOT_USER_AGENTS) {
+        const pattern = new RegExp(`^\\s*user-agent:\\s*${bot}\\s*$`, "im");
+        if (pattern.test(body))
+            found.add(bot);
+    }
+    return [...found].sort((a, b) => a.localeCompare(b));
+}
+function parseLinkRelations(linkHeader) {
+    if (!linkHeader)
+        return [];
+    const relations = new Set();
+    for (const part of linkHeader.split(/,(?=\s*<)/)) {
+        const relMatch = part.match(/\brel\s*=\s*"([^"]+)"/i) ?? part.match(/\brel\s*=\s*'([^']+)'/i) ?? part.match(/\brel\s*=\s*([^\s;]+)/i);
+        if (!relMatch)
+            continue;
+        for (const rel of relMatch[1].split(/\s+/)) {
+            const normalized = rel.trim().toLowerCase();
+            if (normalized)
+                relations.add(normalized);
+        }
+    }
+    return [...relations].sort((a, b) => a.localeCompare(b));
+}
+function isPresentJsonOrDocument(probe) {
+    if (!probe || !isSuccessfulStatus(probe.status))
+        return false;
+    if (looksLikeHtml(probe.body, probe.contentType))
+        return false;
+    return true;
+}
+export function analyzeAgentReady(input) {
+    const issues = [];
+    const robotsBody = input.robotsTxt?.body ?? "";
+    const contentSignals = robotsBody ? extractContentSignals(robotsBody) : [];
+    const aiBotUserAgents = robotsBody ? extractAiBotUserAgents(robotsBody) : [];
+    const llmsStatus = input.llmsTxt?.status ?? null;
+    const llmsBody = input.llmsTxt?.body ?? "";
+    const llmsIsHtml = looksLikeHtml(llmsBody, input.llmsTxt?.contentType);
+    const llmsOk = isSuccessfulStatus(llmsStatus) && !llmsIsHtml && llmsBody.trim().length > 0;
+    const llmsHasTitle = /^#\s+\S+/m.test(llmsBody);
+    const markdownType = input.markdown?.contentType ?? "";
+    const markdownOk = isSuccessfulStatus(input.markdown?.status ?? null) &&
+        /text\/markdown|text\/x-markdown/i.test(markdownType) &&
+        !looksLikeHtml(input.markdown?.body, markdownType);
+    const linkHeader = input.homepage?.headers?.link ?? input.homepage?.headers?.Link;
+    const linkRelations = parseLinkRelations(linkHeader);
+    const agentLinkRelations = linkRelations.filter((rel) => AGENT_LINK_RELS.includes(rel));
+    const wellKnown = {
+        mcpServerCard: isPresentJsonOrDocument(input.wellKnown?.mcpServerCard),
+        agentSkills: isPresentJsonOrDocument(input.wellKnown?.agentSkills),
+        apiCatalog: isPresentJsonOrDocument(input.wellKnown?.apiCatalog),
+        ard: isPresentJsonOrDocument(input.wellKnown?.ard),
+        a2aAgentCard: isPresentJsonOrDocument(input.wellKnown?.a2aAgentCard),
+    };
+    const robotsStatus = input.robotsTxt?.status ?? null;
+    if (!isSuccessfulStatus(robotsStatus) || !robotsBody.trim()) {
+        issues.push(issue("agent-robots-missing", "warning", "robots.txt is missing or empty; agents cannot discover crawl policy or Content Signals."));
+    }
+    else {
+        if (contentSignals.length === 0) {
+            issues.push(issue("agent-missing-content-signals", "warning", "robots.txt has no Content-Signal directives (ai-train / search / ai-input)."));
+        }
+        if (aiBotUserAgents.length === 0) {
+            issues.push(issue("agent-missing-ai-bot-rules", "warning", "robots.txt has no explicit AI bot User-agent rules (e.g. GPTBot, ClaudeBot, Google-Extended)."));
+        }
+    }
+    if (!llmsOk) {
+        issues.push(issue("agent-missing-llms-txt", "warning", "llms.txt is missing or not a plain-text overview at /llms.txt."));
+    }
+    else if (!llmsHasTitle) {
+        issues.push(issue("agent-llms-txt-incomplete", "review", "llms.txt exists but has no H1 title line (# Site Name)."));
+    }
+    if (!markdownOk) {
+        issues.push(issue("agent-missing-markdown-negotiation", "warning", "Homepage does not negotiate Markdown (Accept: text/markdown → Content-Type: text/markdown)."));
+    }
+    if (agentLinkRelations.length === 0) {
+        issues.push(issue("agent-missing-link-headers", "review", 'Homepage has no agent-useful Link headers (rel="api-catalog", "service-doc", "service-desc", or "describedby").'));
+    }
+    const wellKnownPresent = Object.values(wellKnown).some(Boolean);
+    if (!wellKnownPresent) {
+        issues.push(issue("agent-missing-protocol-discovery", "review", "No agent protocol discovery endpoints found (MCP Server Card, Agent Skills, API Catalog, ARD, or A2A Agent Card)."));
+    }
+    const findings = {
+        robotsTxt: {
+            status: robotsStatus,
+            hasContentSignals: contentSignals.length > 0,
+            contentSignals,
+            aiBotUserAgents,
+        },
+        llmsTxt: {
+            url: input.llmsTxt?.url ?? `${input.origin}/llms.txt`,
+            status: llmsStatus,
+            hasTitle: llmsHasTitle,
+        },
+        markdownNegotiation: {
+            url: input.markdown?.url ?? input.origin,
+            status: input.markdown?.status ?? null,
+            contentType: input.markdown?.contentType,
+            supportsMarkdown: markdownOk,
+        },
+        linkHeaders: {
+            relations: agentLinkRelations,
+        },
+        wellKnown,
+    };
+    return {
+        url: input.origin,
+        findings,
+        issues,
+    };
+}
+async function fetchProbe(url, init = {}, timeoutMs = 10_000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            redirect: "follow",
+            signal: controller.signal,
+            ...init,
+            headers: {
+                "user-agent": DEFAULT_USER_AGENT,
+                ...(init.headers ?? {}),
+            },
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key.toLowerCase()] = value;
+        });
+        const contentType = headers["content-type"];
+        const body = await response.text();
+        return {
+            url,
+            status: response.status,
+            contentType,
+            body: body.slice(0, 100_000),
+            headers,
+        };
+    }
+    catch {
+        return { url, status: null };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function runAgentReadyCheck(startUrl, timeoutMs = 10_000) {
+    const origin = new URL(startUrl).origin;
+    const [robotsTxt, llmsTxt, markdown, homepage, mcpServerCard, agentSkills, apiCatalog, ard, a2aAgentCard,] = await Promise.all([
+        fetchProbe(`${origin}/robots.txt`, {}, timeoutMs),
+        fetchProbe(`${origin}/llms.txt`, {}, timeoutMs),
+        fetchProbe(origin, {
+            headers: {
+                accept: "text/markdown, text/x-markdown;q=0.9, text/plain;q=0.8, */*;q=0.1",
+            },
+        }, timeoutMs),
+        fetchProbe(origin, {}, timeoutMs),
+        fetchProbe(`${origin}/.well-known/mcp/server-card.json`, {}, timeoutMs),
+        fetchProbe(`${origin}/.well-known/agent-skills/index.json`, {}, timeoutMs),
+        fetchProbe(`${origin}/.well-known/api-catalog`, {}, timeoutMs),
+        fetchProbe(`${origin}/.well-known/ai-catalog.json`, {}, timeoutMs),
+        fetchProbe(`${origin}/.well-known/agent-card.json`, {}, timeoutMs),
+    ]);
+    return analyzeAgentReady({
+        origin,
+        robotsTxt,
+        llmsTxt,
+        markdown,
+        homepage,
+        wellKnown: {
+            mcpServerCard,
+            agentSkills,
+            apiCatalog,
+            ard,
+            a2aAgentCard,
+        },
+    });
+}

package/dist/checks/analyze.d.ts

@@ -0,0 +1,15 @@
+import { type ReportRecord, type Tier1ReportData } from "../analyze/report.js";
+import type { AnalyzeCheckResult } from "./types.js";
+export type AnalyzeCheckOptions = {
+    records?: ReportRecord[];
+    inputPath?: string;
+    reportPath?: string;
+    reportJsonPath?: string;
+    siteUrl?: string;
+    errorsOnly?: boolean;
+    writeReport?: boolean;
+    redirectOnly?: boolean;
+    tier1?: Tier1ReportData;
+};
+export declare function runAnalyzeCheck(options: AnalyzeCheckOptions): Promise<AnalyzeCheckResult>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/checks/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/checks/analyze.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAW5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB,CAAC;AAuBF,wBAAsB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA4C/F"}

package/dist/checks/analyze.js

@@ -0,0 +1,63 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parseReport } from "../analyze/report.js";
+import { buildStackProfile } from "../analyze/stack.js";
+import { buildStructuredReport, renderReportMarkdown, } from "../analyze/structuredReport.js";
+import { defaultReportJsonPathForInput, defaultReportPathForInput, } from "../crawler/outputPaths.js";
+function loadRecords(options) {
+    if (options.records !== undefined) {
+        return {
+            records: options.records,
+            inputPath: options.inputPath ?? "in-memory-crawl.json",
+        };
+    }
+    if (!options.inputPath) {
+        throw new Error("Analyze check requires crawl records or an inputPath to an existing JSON report.");
+    }
+    const inputPath = resolve(options.inputPath);
+    const raw = readFileSync(inputPath, "utf8");
+    const json = JSON.parse(raw);
+    return {
+        records: parseReport(json),
+        inputPath,
+    };
+}
+export async function runAnalyzeCheck(options) {
+    const { records, inputPath } = loadRecords(options);
+    const reportPath = resolve(options.reportPath ?? defaultReportPathForInput(inputPath));
+    const reportJsonPath = resolve(options.reportJsonPath ?? defaultReportJsonPathForInput(inputPath));
+    const redirectOnly = options.redirectOnly ?? false;
+    const stackProfile = redirectOnly
+        ? { detections: [], tracking: { tagManager: [], analytics: [] } }
+        : buildStackProfile(records, {
+            securityHeaders: options.tier1?.securityHeaders,
+            dns: options.tier1?.dns,
+            robotsTxt: options.tier1?.robotsTxt,
+        });
+    const report = await buildStructuredReport(inputPath, records, options.tier1, {
+        redirectOnly,
+        stackProfile,
+    });
+    // errorsOnly currently filters only the Markdown presentation of page-level noise;
+    // the structured JSON keeps the full finding set for machine consumers.
+    const markdown = renderReportMarkdown(options.errorsOnly
+        ? {
+            ...report,
+            findings: report.findings.filter((finding) => finding.severity === "critical" || finding.severity === "error"),
+        }
+        : report);
+    if (options.writeReport !== false) {
+        mkdirSync(dirname(reportPath), { recursive: true });
+        writeFileSync(reportPath, markdown, "utf8");
+        mkdirSync(dirname(reportJsonPath), { recursive: true });
+        writeFileSync(reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    }
+    return {
+        inputPath,
+        reportPath,
+        reportJsonPath,
+        markdown,
+        report,
+        pagesAnalyzed: records.length,
+    };
+}

package/dist/checks/crawl.d.ts

@@ -0,0 +1,28 @@
+import { type CheckGroup } from "../crawler/checkGroups.js";
+import type { CrawlCheckResult } from "./types.js";
+export type CrawlCheckOptions = {
+    startUrl: string;
+    outputPath?: string;
+    maxPages?: number;
+    delayMs?: number;
+    timeoutMs?: number;
+    concurrency?: number;
+    burstDelayMs?: number;
+    sitemapStart?: boolean;
+    sitemapUrl?: string;
+    excludePatterns?: string[];
+    respectRobotsTxt?: boolean;
+    activeGroups?: Set<CheckGroup>;
+    only?: string;
+    skip?: string;
+    revealSecrets?: boolean;
+    quiet?: boolean;
+};
+export declare function prepareCrawlSeedUrls(options: CrawlCheckOptions): Promise<{
+    normalizedStartUrl: string;
+    seedUrls: string[];
+    outputPath: string;
+    activeGroups: Set<CheckGroup>;
+}>;
+export declare function runCrawlCheck(options: CrawlCheckOptions): Promise<CrawlCheckResult>;
+//# sourceMappingURL=crawl.d.ts.map

package/dist/checks/crawl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawl.d.ts","sourceRoot":"","sources":["../../src/checks/crawl.ts"],"names":[],"mappings":"AAOA,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAKjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC;IAC9E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;CAC/B,CAAC,CAyDD;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiCzF"}

package/dist/checks/crawl.js

@@ -0,0 +1,86 @@
+import { DEFAULT_BURST_DELAY_MS, DEFAULT_CONCURRENCY, DEFAULT_DELAY_MS, DEFAULT_MAX_PAGES, DEFAULT_TIMEOUT_MS, } from "../crawler/defaults.js";
+import { resolveActiveGroups } from "../crawler/checkGroups.js";
+import { buildDefaultOutputPaths } from "../crawler/outputPaths.js";
+import { runCrawler } from "../crawler/runCrawler.js";
+import { collectSitemapPageUrls } from "./sitemap.js";
+import { isHttpUrl, matchesExcludePattern, normalizeUrl } from "../crawler/urlUtils.js";
+export async function prepareCrawlSeedUrls(options) {
+    if (!isHttpUrl(options.startUrl)) {
+        throw new Error("<start-url> must be a valid http(s) URL.");
+    }
+    const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
+    const delayMs = options.delayMs ?? DEFAULT_DELAY_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+    const burstDelayMs = options.burstDelayMs ?? DEFAULT_BURST_DELAY_MS;
+    if (!Number.isFinite(maxPages) || maxPages <= 0)
+        throw new Error("--max-pages must be a positive number.");
+    if (!Number.isFinite(delayMs) || delayMs < 0)
+        throw new Error("--delay-ms must be zero or a positive number.");
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        throw new Error("--timeout-ms must be a positive number.");
+    if (!Number.isFinite(concurrency) || concurrency <= 0)
+        throw new Error("--concurrency must be a positive number.");
+    if (!Number.isFinite(burstDelayMs) || burstDelayMs < 0) {
+        throw new Error("--burst-delay-ms must be zero or a positive number.");
+    }
+    let activeGroups = options.activeGroups;
+    if (!activeGroups) {
+        try {
+            activeGroups = resolveActiveGroups({ only: options.only, skip: options.skip });
+        }
+        catch (error) {
+            throw new Error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    const normalizedStartUrl = normalizeUrl(options.startUrl);
+    const defaultPaths = buildDefaultOutputPaths(normalizedStartUrl);
+    const outputPath = options.outputPath ?? defaultPaths.rawJson;
+    const excludePatterns = options.excludePatterns ?? [];
+    const sitemapPageUrls = await collectSitemapPageUrls(normalizedStartUrl, timeoutMs, [], options.sitemapUrl);
+    let seedUrls = [normalizedStartUrl];
+    for (const url of sitemapPageUrls) {
+        if (!seedUrls.includes(url)) {
+            seedUrls.push(url);
+        }
+    }
+    if (options.sitemapStart) {
+        seedUrls = [...sitemapPageUrls];
+        if (!seedUrls.includes(normalizedStartUrl)) {
+            seedUrls.unshift(normalizedStartUrl);
+        }
+    }
+    seedUrls = seedUrls.filter((url) => !matchesExcludePattern(url, excludePatterns));
+    return { normalizedStartUrl, seedUrls, outputPath, activeGroups };
+}
+export async function runCrawlCheck(options) {
+    const { normalizedStartUrl, seedUrls, outputPath, activeGroups } = await prepareCrawlSeedUrls(options);
+    const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
+    const delayMs = options.delayMs ?? DEFAULT_DELAY_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+    const burstDelayMs = options.burstDelayMs ?? DEFAULT_BURST_DELAY_MS;
+    const excludePatterns = options.excludePatterns ?? [];
+    const { records, interrupted } = await runCrawler({
+        startUrl: normalizedStartUrl,
+        outputPath,
+        maxPages: Math.floor(maxPages),
+        delayMs: Math.floor(delayMs),
+        timeoutMs: Math.floor(timeoutMs),
+        concurrency: Math.floor(concurrency),
+        burstDelayMs: Math.floor(burstDelayMs),
+        seedUrls,
+        excludePatterns,
+        respectRobotsTxt: options.respectRobotsTxt ?? false,
+        activeGroups,
+        revealSecrets: options.revealSecrets ?? false,
+        quiet: options.quiet ?? false,
+    });
+    const secretsFound = records.reduce((sum, record) => sum + (record.security?.secrets.length ?? 0), 0);
+    return {
+        records,
+        outputPath,
+        interrupted,
+        secretsFound,
+    };
+}

package/dist/checks/dns.d.ts

@@ -0,0 +1,25 @@
+import { type CheckIssue } from "./issues.js";
+export type DnsRecords = {
+    a: string[];
+    aaaa: string[];
+    cname: string[];
+    mx: Array<{
+        exchange: string;
+        priority: number;
+    }>;
+    txt: string[];
+    ns: string[];
+};
+export type DnsMailSignals = {
+    spf?: string;
+    dmarc?: string;
+};
+export type DnsCheckResult = {
+    hostname: string;
+    records: DnsRecords;
+    mail: DnsMailSignals;
+    issues: CheckIssue[];
+};
+export declare function analyzeDnsRecords(input: string): Promise<DnsCheckResult>;
+export declare function runDnsCheck(startUrl: string): Promise<DnsCheckResult>;
+//# sourceMappingURL=dns.d.ts.map

package/dist/checks/dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","sourceRoot":"","sources":["../../src/checks/dns.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,MAAM,UAAU,GAAG;IACvB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClD,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB,CAAC;AA2CF,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAuC9E;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAE3E"}

package/dist/checks/dns.js

@@ -0,0 +1,80 @@
+import * as nodeDns from "node:dns";
+import { isPlatformPreviewHostname } from "../crawler/urlUtils.js";
+import { issue } from "./issues.js";
+function parseHostname(input) {
+    try {
+        const url = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+        return url.hostname;
+    }
+    catch {
+        return input;
+    }
+}
+async function resolveOptional(resolver, fallback) {
+    try {
+        return await resolver();
+    }
+    catch {
+        return fallback;
+    }
+}
+function flattenTxtRecords(records) {
+    return records.map((parts) => parts.join(""));
+}
+function findSpf(txtRecords) {
+    return txtRecords.find((record) => record.toLowerCase().startsWith("v=spf1"));
+}
+function findDmarc(hostname, txtRecords) {
+    const fromRoot = txtRecords.find((record) => record.toUpperCase().includes("V=DMARC1"));
+    if (fromRoot)
+        return fromRoot;
+    return undefined;
+}
+async function resolveDmarc(hostname) {
+    try {
+        const records = await nodeDns.promises.resolveTxt(`_dmarc.${hostname}`);
+        const flat = flattenTxtRecords(records);
+        return flat.find((record) => record.toUpperCase().includes("V=DMARC1"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function analyzeDnsRecords(input) {
+    const hostname = parseHostname(input);
+    const issues = [];
+    const [a, aaaa, cname, mx, txt, ns] = await Promise.all([
+        resolveOptional(() => nodeDns.promises.resolve4(hostname), []),
+        resolveOptional(() => nodeDns.promises.resolve6(hostname), []),
+        resolveOptional(() => nodeDns.promises.resolveCname(hostname), []),
+        resolveOptional(() => nodeDns.promises.resolveMx(hostname), []),
+        resolveOptional(() => nodeDns.promises.resolveTxt(hostname), []),
+        resolveOptional(() => nodeDns.promises.resolveNs(hostname), []),
+    ]);
+    const flatTxt = flattenTxtRecords(txt);
+    const spf = findSpf(flatTxt);
+    const dmarc = (await resolveDmarc(hostname)) ?? findDmarc(hostname, flatTxt);
+    const skipMailAuthIssues = isPlatformPreviewHostname(hostname);
+    if (!skipMailAuthIssues && !spf) {
+        issues.push(issue("missing-spf", "warning", "No SPF TXT record found."));
+    }
+    if (!skipMailAuthIssues && !dmarc) {
+        issues.push(issue("missing-dmarc", "warning", "No DMARC TXT record found."));
+    }
+    return {
+        hostname,
+        records: {
+            a,
+            aaaa,
+            cname,
+            mx,
+            txt: flatTxt,
+            ns,
+        },
+        mail: { spf, dmarc },
+        issues,
+    };
+}
+export async function runDnsCheck(startUrl) {
+    return analyzeDnsRecords(startUrl);
+}

package/dist/checks/index.d.ts

@@ -0,0 +1,24 @@
+import { CHECK_IDS, DEFAULT_CHECK_IDS } from "./types.js";
+import { CHECK_DEFINITIONS, getCheckDefinition, listChecks, listImplementedChecks } from "./registry.js";
+import { planCheckWaves, runCheck, runChecks } from "./runner.js";
+import { runAnalyzeCheck } from "./analyze.js";
+import { runCrawlCheck, prepareCrawlSeedUrls } from "./crawl.js";
+import { analyzeAgentReady, runAgentReadyCheck } from "./agent-ready.js";
+import { analyzeDnsRecords, runDnsCheck } from "./dns.js";
+import { analyzeRobotsTxt, runRobotsTxtCheck } from "./robots-txt.js";
+import { analyzeSecurityHeaders, runSecurityHeadersCheck } from "./security-headers.js";
+import { analyzeSitemapCompare, runSitemapCheck } from "./sitemap.js";
+import { analyzeRedirect, analyzeWwwAliasRedirect, buildAlternateHostUrl, resolveCanonicalUrl, resolveChecksForRedirect, runRedirectCheck, shouldCheckWwwAlias, toggleWwwHostname } from "./redirect.js";
+export { CHECK_IDS, CHECK_DEFINITIONS, DEFAULT_CHECK_IDS, getCheckDefinition, listChecks, listImplementedChecks, planCheckWaves, runAnalyzeCheck, runCheck, runChecks, runCrawlCheck, prepareCrawlSeedUrls, analyzeAgentReady, runAgentReadyCheck, analyzeDnsRecords, runDnsCheck, analyzeRobotsTxt, runRobotsTxtCheck, analyzeSecurityHeaders, runSecurityHeadersCheck, analyzeSitemapCompare, runSitemapCheck, analyzeRedirect, analyzeWwwAliasRedirect, buildAlternateHostUrl, resolveCanonicalUrl, resolveChecksForRedirect, runRedirectCheck, shouldCheckWwwAlias, toggleWwwHostname, };
+export type { AnalyzeCheckResult, CheckDefinition, CheckExecutionResult, CheckId, CheckOutputs, CheckRunContext, CheckStatus, CrawlCheckResult, ImplementedCheckId, PlannedCheckId, RunChecksOptions, RunChecksResult, } from "./types.js";
+export type { AnalyzeCheckOptions } from "./analyze.js";
+export type { CrawlCheckOptions } from "./crawl.js";
+export type { CheckIssue, CheckIssueSeverity } from "./issues.js";
+export type { AgentReadyCheckResult, AgentReadyFindings } from "./agent-ready.js";
+export type { DnsCheckResult } from "./dns.js";
+export type { RobotsTxtCheckResult } from "./robots-txt.js";
+export type { SecurityHeadersCheckResult } from "./security-headers.js";
+export type { SitemapCheckResult, SitemapCheckOptions } from "./sitemap.js";
+export type { RedirectCheckResult, WwwAliasRedirectProbe } from "./redirect.js";
+export type { Tier1ReportData } from "../analyze/report.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/checks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,QAAQ,EACR,SAAS,EACT,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,GAClB,CAAC;AAEF,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAClF,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAChF,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/checks/index.js

@@ -0,0 +1,12 @@
+import { CHECK_IDS, DEFAULT_CHECK_IDS } from "./types.js";
+import { CHECK_DEFINITIONS, getCheckDefinition, listChecks, listImplementedChecks } from "./registry.js";
+import { planCheckWaves, runCheck, runChecks } from "./runner.js";
+import { runAnalyzeCheck } from "./analyze.js";
+import { runCrawlCheck, prepareCrawlSeedUrls } from "./crawl.js";
+import { analyzeAgentReady, runAgentReadyCheck } from "./agent-ready.js";
+import { analyzeDnsRecords, runDnsCheck } from "./dns.js";
+import { analyzeRobotsTxt, runRobotsTxtCheck } from "./robots-txt.js";
+import { analyzeSecurityHeaders, runSecurityHeadersCheck } from "./security-headers.js";
+import { analyzeSitemapCompare, runSitemapCheck } from "./sitemap.js";
+import { analyzeRedirect, analyzeWwwAliasRedirect, buildAlternateHostUrl, resolveCanonicalUrl, resolveChecksForRedirect, runRedirectCheck, shouldCheckWwwAlias, toggleWwwHostname, } from "./redirect.js";
+export { CHECK_IDS, CHECK_DEFINITIONS, DEFAULT_CHECK_IDS, getCheckDefinition, listChecks, listImplementedChecks, planCheckWaves, runAnalyzeCheck, runCheck, runChecks, runCrawlCheck, prepareCrawlSeedUrls, analyzeAgentReady, runAgentReadyCheck, analyzeDnsRecords, runDnsCheck, analyzeRobotsTxt, runRobotsTxtCheck, analyzeSecurityHeaders, runSecurityHeadersCheck, analyzeSitemapCompare, runSitemapCheck, analyzeRedirect, analyzeWwwAliasRedirect, buildAlternateHostUrl, resolveCanonicalUrl, resolveChecksForRedirect, runRedirectCheck, shouldCheckWwwAlias, toggleWwwHostname, };

package/dist/checks/issues.d.ts

@@ -0,0 +1,8 @@
+export type CheckIssueSeverity = "critical" | "error" | "warning" | "review";
+export type CheckIssue = {
+    id: string;
+    severity: CheckIssueSeverity;
+    message: string;
+};
+export declare function issue(id: string, severity: CheckIssueSeverity, message: string): CheckIssue;
+//# sourceMappingURL=issues.d.ts.map

package/dist/checks/issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../src/checks/issues.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CAE3F"}

package/dist/checks/issues.js

@@ -0,0 +1,3 @@
+export function issue(id, severity, message) {
+    return { id, severity, message };
+}

package/dist/checks/redirect.d.ts

@@ -0,0 +1,38 @@
+import { type CheckIssue } from "./issues.js";
+import type { CheckId } from "./types.js";
+export declare const REDIRECT_STATUS_CODES: Set<number>;
+export declare const PERMANENT_REDIRECT_STATUS_CODES: Set<number>;
+export type RedirectProbeInput = {
+    url: string;
+    status: number | null;
+    location: string | null;
+    resolvedTarget: string | null;
+    headers: Record<string, string>;
+    targetStatus: number | null;
+};
+export type WwwAliasRedirectProbe = {
+    canonicalUrl: string;
+    alternateUrl: string;
+    status: number | null;
+    location: string | null;
+    resolvedTarget: string | null;
+    targetStatus: number | null;
+};
+export type RedirectCheckResult = RedirectProbeInput & {
+    isRedirect: boolean;
+    redirectOnly: boolean;
+    issues: CheckIssue[];
+    wwwAlias?: WwwAliasRedirectProbe;
+};
+export declare function toggleWwwHostname(hostname: string): string;
+export declare function buildAlternateHostUrl(url: string): string;
+export declare function resolveCanonicalUrl(startUrl: string, probe: Pick<RedirectProbeInput, "resolvedTarget">): string;
+export declare function shouldCheckWwwAlias(hostname: string): boolean;
+export declare const REDIRECT_ONLY_CHECK_IDS: CheckId[];
+export declare function analyzeRedirect(input: RedirectProbeInput): RedirectCheckResult;
+export declare function analyzeWwwAliasRedirect(canonicalUrl: string, probe: Pick<RedirectProbeInput, "url" | "status" | "location" | "resolvedTarget" | "targetStatus">): CheckIssue[];
+export declare function isDefaultCheckSet(requestedChecks: CheckId[]): boolean;
+export declare function resolveChecksForRedirect(requestedChecks: CheckId[], redirect: Pick<RedirectCheckResult, "redirectOnly">): CheckId[];
+export declare function checksSkippedByRedirect(requestedChecks: CheckId[], effectiveChecks: CheckId[]): CheckId[];
+export declare function runRedirectCheck(startUrl: string, timeoutMs?: number): Promise<RedirectCheckResult>;
+//# sourceMappingURL=redirect.d.ts.map

package/dist/checks/redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect.d.ts","sourceRoot":"","sources":["../../src/checks/redirect.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,eAAO,MAAM,qBAAqB,aAAqC,CAAC;AACxE,eAAO,MAAM,+BAA+B,aAAsB,CAAC;AAEnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,GAAG,MAAM,CAE/G;AAMD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAM7D;AAED,eAAO,MAAM,uBAAuB,EAAE,OAAO,EAAuB,CAAC;AAmBrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CAyD9E;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,KAAK,GAAG,QAAQ,GAAG,UAAU,GAAG,gBAAgB,GAAG,cAAc,CAAC,GACjG,UAAU,EAAE,CAyEd;AAED,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,OAAO,EAAE,GAAG,OAAO,CAKrE;AAED,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,OAAO,EAAE,EAC1B,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,GAClD,OAAO,EAAE,CAWX;AAED,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,OAAO,EAAE,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAGzG;AA0DD,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8BrH"}