@eightmedia/flightcheck 0.0.0-stage → 1.0.0

package/dist/checks/redirect.js

@@ -0,0 +1,209 @@
+import { DEFAULT_TIMEOUT_MS, DEFAULT_USER_AGENT } from "../crawler/defaults.js";
+import { isPlatformPreviewHostname, normalizeUrl } from "../crawler/urlUtils.js";
+import { issue } from "./issues.js";
+import { DEFAULT_CHECK_IDS } from "./types.js";
+export const REDIRECT_STATUS_CODES = new Set([301, 302, 303, 307, 308]);
+export const PERMANENT_REDIRECT_STATUS_CODES = new Set([301, 308]);
+export function toggleWwwHostname(hostname) {
+    const lower = hostname.toLowerCase();
+    return lower.startsWith("www.") ? lower.slice(4) : `www.${lower}`;
+}
+export function buildAlternateHostUrl(url) {
+    const parsed = new URL(normalizeUrl(url));
+    parsed.hostname = toggleWwwHostname(parsed.hostname);
+    return parsed.toString();
+}
+export function resolveCanonicalUrl(startUrl, probe) {
+    return probe.resolvedTarget ?? normalizeUrl(startUrl);
+}
+function hostnameFromUrl(url) {
+    return new URL(url).hostname.toLowerCase();
+}
+export function shouldCheckWwwAlias(hostname) {
+    if (hostname === "localhost")
+        return false;
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname))
+        return false;
+    if (hostname.includes(":"))
+        return false;
+    if (isPlatformPreviewHostname(hostname))
+        return false;
+    return true;
+}
+export const REDIRECT_ONLY_CHECK_IDS = ["dns", "analyze"];
+function headersToRecord(headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+        record[key.toLowerCase()] = value;
+    });
+    return record;
+}
+function resolveLocation(url, location) {
+    if (!location?.trim())
+        return null;
+    try {
+        return normalizeUrl(new URL(location.trim(), url).toString());
+    }
+    catch {
+        return null;
+    }
+}
+export function analyzeRedirect(input) {
+    const issues = [];
+    const isRedirect = input.status !== null && REDIRECT_STATUS_CODES.has(input.status);
+    const redirectOnly = isRedirect;
+    const isHttps = input.url.startsWith("https://");
+    if (!isRedirect) {
+        return {
+            ...input,
+            isRedirect: false,
+            redirectOnly: false,
+            issues,
+        };
+    }
+    if (!input.location) {
+        issues.push(issue("redirect-missing-location", "error", "Redirect response is missing a Location header."));
+    }
+    else if (!input.resolvedTarget) {
+        issues.push(issue("redirect-invalid-location", "error", "Redirect Location header is not a valid URL."));
+    }
+    if (input.status !== null && !PERMANENT_REDIRECT_STATUS_CODES.has(input.status)) {
+        issues.push(issue("redirect-temporary-status", "warning", `Redirect uses status ${input.status}; use 301 or 308 for permanent domain redirects.`));
+    }
+    if (isHttps && !input.headers["strict-transport-security"]) {
+        issues.push(issue("redirect-missing-hsts", "warning", "Strict-Transport-Security header is missing on the redirect response."));
+    }
+    if (input.resolvedTarget && input.targetStatus !== null && input.targetStatus >= 400) {
+        issues.push(issue("redirect-target-unreachable", "error", `Redirect target returned status ${input.targetStatus}: ${input.resolvedTarget}`));
+    }
+    return {
+        ...input,
+        isRedirect,
+        redirectOnly,
+        issues,
+    };
+}
+export function analyzeWwwAliasRedirect(canonicalUrl, probe) {
+    const issues = [];
+    const canonicalHost = hostnameFromUrl(canonicalUrl);
+    if (probe.status === null) {
+        issues.push(issue("redirect-www-alias-unreachable", "error", `Alternate host is unreachable and should redirect to ${canonicalHost}: ${probe.url}`));
+        return issues;
+    }
+    if (!REDIRECT_STATUS_CODES.has(probe.status)) {
+        issues.push(issue("redirect-www-alias-no-redirect", "error", `Alternate host should redirect to ${canonicalHost} but returned status ${probe.status}: ${probe.url}`));
+        return issues;
+    }
+    if (!probe.location) {
+        issues.push(issue("redirect-www-alias-missing-location", "error", `Alternate host redirect is missing a Location header: ${probe.url}`));
+    }
+    else if (!probe.resolvedTarget) {
+        issues.push(issue("redirect-www-alias-invalid-location", "error", `Alternate host redirect Location header is not a valid URL: ${probe.url}`));
+    }
+    else if (hostnameFromUrl(probe.resolvedTarget) !== canonicalHost) {
+        issues.push(issue("redirect-www-alias-wrong-target", "error", `Alternate host redirects to ${probe.resolvedTarget} instead of ${canonicalHost}: ${probe.url}`));
+    }
+    if (probe.status !== null && !PERMANENT_REDIRECT_STATUS_CODES.has(probe.status)) {
+        issues.push(issue("redirect-www-alias-temporary-status", "warning", `Alternate host redirect uses status ${probe.status}; use 301 or 308 for permanent domain redirects: ${probe.url}`));
+    }
+    if (probe.resolvedTarget && probe.targetStatus !== null && probe.targetStatus >= 400) {
+        issues.push(issue("redirect-www-alias-target-unreachable", "error", `Alternate host redirect target returned status ${probe.targetStatus}: ${probe.resolvedTarget}`));
+    }
+    return issues;
+}
+export function isDefaultCheckSet(requestedChecks) {
+    return (requestedChecks.length === DEFAULT_CHECK_IDS.length &&
+        DEFAULT_CHECK_IDS.every((id) => requestedChecks.includes(id)));
+}
+export function resolveChecksForRedirect(requestedChecks, redirect) {
+    if (!redirect.redirectOnly) {
+        return requestedChecks;
+    }
+    const explicit = new Set(requestedChecks);
+    if (explicit.has("crawl") && !isDefaultCheckSet(requestedChecks)) {
+        return requestedChecks;
+    }
+    return REDIRECT_ONLY_CHECK_IDS.filter((id) => explicit.has(id));
+}
+export function checksSkippedByRedirect(requestedChecks, effectiveChecks) {
+    const effective = new Set(effectiveChecks);
+    return requestedChecks.filter((id) => !effective.has(id));
+}
+async function probeTargetStatus(targetUrl, timeoutMs) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(targetUrl, {
+            method: "HEAD",
+            redirect: "manual",
+            signal: controller.signal,
+            headers: { "user-agent": DEFAULT_USER_AGENT },
+        });
+        clearTimeout(timeout);
+        return response.status;
+    }
+    catch {
+        return null;
+    }
+}
+async function probeRedirect(url, timeoutMs) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(url, {
+            redirect: "manual",
+            signal: controller.signal,
+            headers: { "user-agent": DEFAULT_USER_AGENT },
+        });
+        clearTimeout(timeout);
+        const location = response.headers.get("location");
+        const resolvedTarget = resolveLocation(url, location);
+        const headers = headersToRecord(response.headers);
+        const targetStatus = resolvedTarget && response.status !== null && REDIRECT_STATUS_CODES.has(response.status)
+            ? await probeTargetStatus(resolvedTarget, timeoutMs)
+            : null;
+        return {
+            url,
+            status: response.status,
+            location,
+            resolvedTarget,
+            headers,
+            targetStatus,
+        };
+    }
+    catch {
+        return {
+            url,
+            status: null,
+            location: null,
+            resolvedTarget: null,
+            headers: {},
+            targetStatus: null,
+        };
+    }
+}
+export async function runRedirectCheck(startUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const url = normalizeUrl(startUrl);
+    const startProbe = await probeRedirect(url, timeoutMs);
+    const result = analyzeRedirect(startProbe);
+    const canonicalUrl = resolveCanonicalUrl(url, startProbe);
+    const canonicalHost = hostnameFromUrl(canonicalUrl);
+    if (!shouldCheckWwwAlias(canonicalHost)) {
+        return result;
+    }
+    const alternateUrl = buildAlternateHostUrl(canonicalUrl);
+    const alternateProbe = hostnameFromUrl(url) === hostnameFromUrl(alternateUrl)
+        ? startProbe
+        : await probeRedirect(alternateUrl, timeoutMs);
+    const wwwAliasIssues = analyzeWwwAliasRedirect(canonicalUrl, alternateProbe);
+    result.wwwAlias = {
+        canonicalUrl,
+        alternateUrl,
+        status: alternateProbe.status,
+        location: alternateProbe.location,
+        resolvedTarget: alternateProbe.resolvedTarget,
+        targetStatus: alternateProbe.targetStatus,
+    };
+    result.issues.push(...wwwAliasIssues);
+    return result;
+}

package/dist/checks/registry.d.ts

@@ -0,0 +1,8 @@
+import { CHECK_IDS, type CheckDefinition, type CheckExecutionResult, type CheckId, type CheckRunContext } from "./types.js";
+export { CHECK_IDS };
+export declare const CHECK_DEFINITIONS: Record<CheckId, CheckDefinition>;
+export declare function getCheckDefinition(id: CheckId): CheckDefinition;
+export declare function listChecks(): CheckDefinition[];
+export declare function listImplementedChecks(): CheckDefinition[];
+export declare function runRegisteredCheck(context: CheckRunContext, id: CheckId): Promise<CheckExecutionResult>;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/checks/registry.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,KAAK,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAE5H,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,OAAO,EAAE,eAAe,CAyP9D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,eAAe,CAE/D;AAED,wBAAgB,UAAU,IAAI,eAAe,EAAE,CAE9C;AAED,wBAAgB,qBAAqB,IAAI,eAAe,EAAE,CAEzD;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAE7G"}

package/dist/checks/registry.js

@@ -0,0 +1,275 @@
+import { runAgentReadyCheck } from "./agent-ready.js";
+import { runAnalyzeCheck } from "./analyze.js";
+import { runCrawlCheck } from "./crawl.js";
+import { runDnsCheck } from "./dns.js";
+import { runRobotsTxtCheck } from "./robots-txt.js";
+import { runSecurityHeadersCheck } from "./security-headers.js";
+import { runSitemapCheck } from "./sitemap.js";
+import { normalizeUrl } from "../crawler/urlUtils.js";
+import { CHECK_IDS } from "./types.js";
+export { CHECK_IDS };
+export const CHECK_DEFINITIONS = {
+    crawl: {
+        id: "crawl",
+        name: "Crawl",
+        description: "Crawl pages and collect SEO, metadata, tracking, and security verification data.",
+        dependencies: [],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const data = await runCrawlCheck({
+                    startUrl: context.startUrl,
+                    ...context.options.crawl,
+                });
+                context.outputs.crawl = data;
+                return {
+                    id: "crawl",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "crawl",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    analyze: {
+        id: "analyze",
+        name: "Analyze",
+        description: "Turn crawl JSON into structured report JSON + Markdown.",
+        dependencies: ["crawl"],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const crawlOutput = context.outputs.crawl;
+                const redirectOnly = context.outputs.redirect?.redirectOnly ?? false;
+                const data = await runAnalyzeCheck({
+                    ...context.options.analyze,
+                    records: context.options.analyze?.records ??
+                        crawlOutput?.records ??
+                        (redirectOnly ? [] : undefined),
+                    inputPath: context.options.analyze?.inputPath ??
+                        crawlOutput?.outputPath ??
+                        (redirectOnly ? "redirect-only.json" : undefined),
+                    reportPath: context.options.analyze?.reportPath,
+                    reportJsonPath: context.options.analyze?.reportJsonPath,
+                    tier1: {
+                        redirect: context.outputs.redirect,
+                        securityHeaders: context.outputs.securityHeaders,
+                        dns: context.outputs.dns,
+                        robotsTxt: context.outputs.robotsTxt,
+                        sitemap: context.outputs.sitemap,
+                        agentReady: context.outputs.agentReady,
+                        ...context.options.analyze?.tier1,
+                    },
+                    redirectOnly,
+                });
+                context.outputs.analyze = data;
+                return {
+                    id: "analyze",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "analyze",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    lighthouse: {
+        id: "lighthouse",
+        name: "Lighthouse",
+        description: "Run Lighthouse performance, accessibility, and best-practices audits.",
+        dependencies: [],
+        implemented: false,
+        run: async () => ({
+            id: "lighthouse",
+            status: "unsupported",
+            error: "Lighthouse check is not implemented yet.",
+            durationMs: 0,
+        }),
+    },
+    "security-headers": {
+        id: "security-headers",
+        name: "Security headers",
+        description: "Verify HTTP security headers such as CSP, HSTS, and X-Frame-Options.",
+        dependencies: [],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const data = await runSecurityHeadersCheck(context.startUrl);
+                context.outputs.securityHeaders = data;
+                return {
+                    id: "security-headers",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "security-headers",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    dns: {
+        id: "dns",
+        name: "DNS ownership",
+        description: "Verify DNS records and domain ownership signals.",
+        dependencies: [],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const data = await runDnsCheck(context.startUrl);
+                context.outputs.dns = data;
+                return {
+                    id: "dns",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "dns",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    "robots-txt": {
+        id: "robots-txt",
+        name: "Robots.txt",
+        description: "Report robots.txt presence, sitemap directives, and crawl blocks.",
+        dependencies: [],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const data = await runRobotsTxtCheck(context.startUrl);
+                context.outputs.robotsTxt = data;
+                return {
+                    id: "robots-txt",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "robots-txt",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    sitemap: {
+        id: "sitemap",
+        name: "Sitemap",
+        description: "Verify sitemap exists and matches crawled URLs.",
+        dependencies: ["crawl"],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            const crawlOutput = context.outputs.crawl;
+            if (!crawlOutput) {
+                return {
+                    id: "sitemap",
+                    status: "skipped",
+                    error: "Sitemap check requires crawl output.",
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            try {
+                const crawledUrls = crawlOutput.records.map((record) => normalizeUrl(record.url));
+                const data = await runSitemapCheck({
+                    startUrl: context.startUrl,
+                    crawledUrls,
+                    robotsSitemapUrls: context.outputs.robotsTxt?.sitemapUrls,
+                    excludePatterns: context.options.sitemap?.excludePatterns ?? context.options.crawl?.excludePatterns,
+                    mismatchThresholdPercent: context.options.sitemap?.mismatchThresholdPercent,
+                    timeoutMs: context.options.sitemap?.timeoutMs,
+                });
+                context.outputs.sitemap = data;
+                return {
+                    id: "sitemap",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "sitemap",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+    "agent-ready": {
+        id: "agent-ready",
+        name: "Agent readiness",
+        description: "Check AI agent discoverability: Content Signals, AI bot rules, llms.txt, Markdown negotiation, Link headers, and well-known protocol cards.",
+        dependencies: [],
+        implemented: true,
+        run: async (context) => {
+            const startedAt = Date.now();
+            try {
+                const data = await runAgentReadyCheck(context.startUrl);
+                context.outputs.agentReady = data;
+                return {
+                    id: "agent-ready",
+                    status: "success",
+                    data,
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+            catch (error) {
+                return {
+                    id: "agent-ready",
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                };
+            }
+        },
+    },
+};
+export function getCheckDefinition(id) {
+    return CHECK_DEFINITIONS[id];
+}
+export function listChecks() {
+    return CHECK_IDS.map((id) => CHECK_DEFINITIONS[id]);
+}
+export function listImplementedChecks() {
+    return listChecks().filter((check) => check.implemented);
+}
+export async function runRegisteredCheck(context, id) {
+    return CHECK_DEFINITIONS[id].run(context);
+}

package/dist/checks/robots-txt.d.ts

@@ -0,0 +1,16 @@
+import { type CheckIssue } from "./issues.js";
+export type AnalyzeRobotsTxtInput = {
+    url: string;
+    status: number | null;
+    body?: string;
+};
+export type RobotsTxtCheckResult = {
+    url: string;
+    status: number | null;
+    body?: string;
+    sitemapUrls: string[];
+    issues: CheckIssue[];
+};
+export declare function analyzeRobotsTxt(input: AnalyzeRobotsTxtInput): RobotsTxtCheckResult;
+export declare function runRobotsTxtCheck(startUrl: string, timeoutMs?: number): Promise<RobotsTxtCheckResult>;
+//# sourceMappingURL=robots-txt.d.ts.map

package/dist/checks/robots-txt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"robots-txt.d.ts","sourceRoot":"","sources":["../../src/checks/robots-txt.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGrD,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB,CAAC;AAgDF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,oBAAoB,CA2CnF;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAS,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmB3G"}

package/dist/checks/robots-txt.js

@@ -0,0 +1,99 @@
+import robotsParser from "robots-parser";
+import { issue } from "./issues.js";
+import { DEFAULT_USER_AGENT } from "../crawler/defaults.js";
+function extractSitemapUrls(body) {
+    const urls = [];
+    for (const line of body.split("\n")) {
+        const match = line.match(/^\s*sitemap:\s*(.+)\s*$/i);
+        if (match) {
+            urls.push(match[1].trim());
+        }
+    }
+    return urls;
+}
+function hasMalformedRobotsLines(body) {
+    for (const line of body.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        if (/^sitemap:/i.test(trimmed))
+            continue;
+        const colonIndex = trimmed.indexOf(":");
+        if (colonIndex === -1) {
+            if (/^(user-agent|disallow|allow|crawl-delay)\b/i.test(trimmed)) {
+                return true;
+            }
+            continue;
+        }
+        const directive = trimmed.slice(0, colonIndex).trim();
+        const value = trimmed.slice(colonIndex + 1).trim();
+        if (/^(disallow|allow|crawl-delay)$/i.test(directive) && value.length === 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function blocksAllUserAgents(body, robotsUrl) {
+    try {
+        const createRobotsParser = robotsParser;
+        const parsed = createRobotsParser(robotsUrl, body);
+        return parsed.isAllowed(`${new URL(robotsUrl).origin}/`, DEFAULT_USER_AGENT) === false;
+    }
+    catch {
+        return false;
+    }
+}
+export function analyzeRobotsTxt(input) {
+    const issues = [];
+    const { url, status, body } = input;
+    if (status === null || status === 404) {
+        issues.push(issue("robots-missing", "warning", "robots.txt is missing."));
+        return { url, status, body, sitemapUrls: [], issues };
+    }
+    if (!body) {
+        issues.push(issue("robots-unparseable", "error", "robots.txt response body is empty."));
+        return { url, status, body, sitemapUrls: [], issues };
+    }
+    if (hasMalformedRobotsLines(body)) {
+        issues.push(issue("robots-unparseable", "error", "robots.txt contains malformed directives."));
+    }
+    let sitemapUrls = [];
+    try {
+        const createRobotsParser = robotsParser;
+        const parsed = createRobotsParser(url, body);
+        sitemapUrls = parsed.getSitemaps();
+    }
+    catch {
+        issues.push(issue("robots-unparseable", "error", "robots.txt could not be parsed."));
+        return { url, status, body, sitemapUrls: [], issues };
+    }
+    if (sitemapUrls.length === 0) {
+        sitemapUrls = extractSitemapUrls(body);
+    }
+    if (blocksAllUserAgents(body, url)) {
+        issues.push(issue("robots-blocks-all", "critical", "robots.txt disallows all crawling for User-agent: *."));
+    }
+    if (sitemapUrls.length === 0) {
+        issues.push(issue("robots-missing-sitemap", "warning", "robots.txt has no Sitemap directive."));
+    }
+    return { url, status, body, sitemapUrls, issues };
+}
+export async function runRobotsTxtCheck(startUrl, timeoutMs = 10_000) {
+    const origin = new URL(startUrl).origin;
+    const robotsUrl = `${origin}/robots.txt`;
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(robotsUrl, {
+            redirect: "follow",
+            signal: controller.signal,
+            headers: { "user-agent": DEFAULT_USER_AGENT },
+        });
+        clearTimeout(timeout);
+        const body = response.ok ? await response.text() : undefined;
+        return analyzeRobotsTxt({ url: robotsUrl, status: response.status, body });
+    }
+    catch {
+        return analyzeRobotsTxt({ url: robotsUrl, status: null });
+    }
+}

package/dist/checks/runner.d.ts

@@ -0,0 +1,9 @@
+import { CHECK_DEFINITIONS, getCheckDefinition, listChecks, listImplementedChecks } from "./registry.js";
+import { analyzeRedirect, resolveChecksForRedirect, type RedirectCheckResult } from "./redirect.js";
+import { type CheckExecutionResult, type CheckId, type RunChecksOptions, type RunChecksResult } from "./types.js";
+export declare function planCheckWaves(requestedChecks: CheckId[]): CheckId[][];
+export declare function runCheck(id: CheckId, options: RunChecksOptions): Promise<CheckExecutionResult>;
+export declare function probeStartUrlRedirect(startUrl: string): Promise<RedirectCheckResult>;
+export declare function runChecks(options: RunChecksOptions): Promise<RunChecksResult>;
+export { CHECK_DEFINITIONS, getCheckDefinition, listChecks, listImplementedChecks, analyzeRedirect, resolveChecksForRedirect };
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/checks/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,UAAU,EAAE,qBAAqB,EAAsB,MAAM,eAAe,CAAC;AAC7H,OAAO,EACL,eAAe,EAEf,wBAAwB,EAExB,KAAK,mBAAmB,EACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAqB,KAAK,oBAAoB,EAAE,KAAK,OAAO,EAAwB,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAE3J,wBAAgB,cAAc,CAAC,eAAe,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,CAqBtE;AAqDD,wBAAsB,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAOpG;AAED,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAE1F;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CA+CnF;AAED,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,UAAU,EAAE,qBAAqB,EAAE,eAAe,EAAE,wBAAwB,EAAE,CAAC"}