meodp 0.0.9 → 0.2.0

package/dist/shared/meodp.c4c70565.cjs

@@ -0,0 +1,477 @@
+'use strict';
+
+const promises = require('node:timers/promises');
+const linkinator = require('linkinator');
+const node_os = require('node:os');
+const report = require('./meodp.2b00b0ae.cjs');
+const promises$1 = require('node:fs/promises');
+const path = require('node:path');
+const process = require('node:process');
+const node_buffer = require('node:buffer');
+const node_util = require('node:util');
+const node_zlib = require('node:zlib');
+const fastXmlParser = require('fast-xml-parser');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+function normalizeUrl(value) {
+  const url = new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+    throw new Error("Expected an HTTP(S) URL without embedded credentials");
+  url.hash = "";
+  return url.href;
+}
+function normalizeTargets(input) {
+  if (!Array.isArray(input))
+    throw new TypeError("Input must be an array of URLs or objects with a url field");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((item, index) => {
+    const value = typeof item === "string" ? { url: item } : item;
+    if (!value || typeof value !== "object" || !("url" in value) || typeof value.url !== "string")
+      throw new TypeError(`Invalid link at index ${index}: expected a url string`);
+    let url;
+    try {
+      url = normalizeUrl(value.url.trim());
+    } catch {
+      throw new TypeError(`Invalid HTTP(S) URL at index ${index}`);
+    }
+    if ("name" in value && value.name !== void 0 && typeof value.name !== "string")
+      throw new TypeError(`Invalid name at index ${index}: expected a string`);
+    return { url, ..."name" in value && typeof value.name === "string" ? { name: value.name } : {} };
+  }).filter((item) => {
+    if (seen.has(item.url))
+      return false;
+    seen.add(item.url);
+    return true;
+  });
+}
+
+function integerOption(value, fallback, name, minimum, maximum) {
+  const result = value ?? fallback;
+  if (!Number.isInteger(result) || result < minimum || result > maximum)
+    throw new RangeError(`${name} must be an integer between ${minimum} and ${maximum}`);
+  return result;
+}
+function normalizeCheckOptions(options) {
+  const concurrency = integerOption(options.concurrency, 5, "concurrency", 1, 100);
+  const timeoutMs = integerOption(options.timeoutMs, 1e4, "timeoutMs", 1, 3e5);
+  const retries = integerOption(options.retries, 1, "retries", 0, 5);
+  const maxRedirects = integerOption(options.maxRedirects, 5, "maxRedirects", 0, 20);
+  const observer = options.observer ?? node_os.hostname();
+  if (!observer.trim())
+    throw new TypeError("observer must not be empty");
+  if (options.previousReport && options.previousReport.observer !== observer)
+    throw new Error("Previous report belongs to another observer; use a separate history file");
+  return { concurrency, timeoutMs, retries, maxRedirects, observer };
+}
+
+function failureDetail(result) {
+  const error = result.failureDetails?.find((item) => item instanceof Error);
+  const parts = [];
+  let current = error;
+  for (let depth = 0; current && typeof current === "object" && depth < 5; depth++) {
+    for (const key of ["name", "code", "message"]) {
+      const value = Reflect.get(current, key);
+      if (typeof value === "string")
+        parts.push(value);
+    }
+    current = "cause" in current ? current.cause : void 0;
+  }
+  const detail = parts.join(": ") || `HTTP ${result.status ?? 0}`;
+  if (/ENOTFOUND|EAI_AGAIN|EAI_FAIL/.test(detail))
+    return { reason: "dns", detail };
+  if (/CERT|TLS|SSL/i.test(detail))
+    return { reason: "tls", detail };
+  if (/timeout|timed out|ETIMEDOUT|UND_ERR_.*TIMEOUT/i.test(detail))
+    return { reason: "timeout", detail };
+  return { reason: result.status ? "http" : "network", detail };
+}
+async function probe(url, timeoutMs, maxRedirects) {
+  const redirects = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = url;
+  for (; ; ) {
+    visited.add(current);
+    const checker = new linkinator.LinkChecker();
+    const { links } = await checker.check({
+      path: current,
+      recurse: false,
+      concurrency: 1,
+      timeout: timeoutMs,
+      retry: false,
+      retryErrors: false,
+      redirects: "error",
+      linksToSkip: async (candidate) => candidate !== current
+    });
+    const result = links.find((item) => item.url === current && !item.parent);
+    if (!result)
+      throw new Error("The HTTP checker returned no result for the requested URL");
+    const httpStatus = result.status || void 0;
+    const base = { finalUrl: current, httpStatus, redirects };
+    if (httpStatus && [301, 302, 303, 307, 308].includes(httpStatus)) {
+      const response = result.failureDetails?.find((item) => "headers" in item);
+      const location = response && "headers" in response ? response.headers.location : void 0;
+      let next;
+      try {
+        if (!location)
+          throw new Error("Missing redirect location");
+        next = normalizeUrl(new URL(location, current).href);
+      } catch {
+        return { ...base, status: "unavailable", reason: "redirect", detail: "Missing or invalid HTTP(S) redirect destination" };
+      }
+      redirects.push({ url: current, status: httpStatus, location: next });
+      if (visited.has(next) || redirects.length > maxRedirects) {
+        return {
+          ...base,
+          status: "unavailable",
+          reason: "redirect",
+          detail: visited.has(next) ? "Redirect loop" : "Redirect limit exceeded"
+        };
+      }
+      current = next;
+      continue;
+    }
+    if (httpStatus && httpStatus >= 200 && httpStatus < 300)
+      return { ...base, status: "reachable" };
+    if (httpStatus && [401, 403, 429, 451, 999].includes(httpStatus))
+      return { ...base, status: "restricted", reason: "http", detail: `HTTP ${httpStatus}: access requires review` };
+    return { ...base, status: "unavailable", ...failureDetail(result) };
+  }
+}
+async function checkLinks(input, options = {}) {
+  const targets = normalizeTargets(input);
+  const { concurrency, timeoutMs, retries, maxRedirects, observer } = normalizeCheckOptions(options);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const previous = new Map(options.previousReport?.results.map((item) => [item.url, item]));
+  const results = [];
+  let cursor = 0;
+  await Promise.all(Array.from({ length: Math.min(concurrency, targets.length) }, async () => {
+    while (cursor < targets.length) {
+      const index = cursor++;
+      const target = targets[index];
+      const start = Date.now();
+      let attempts = 0;
+      let observation;
+      do {
+        if (attempts > 0)
+          await promises.setTimeout(500 * 2 ** (attempts - 1));
+        attempts++;
+        observation = await probe(target.url, timeoutMs, maxRedirects);
+      } while (attempts <= retries && observation.status === "unavailable" && observation.reason !== "redirect" && (!observation.httpStatus || observation.httpStatus >= 500));
+      const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const old = previous.get(target.url);
+      const failed = observation.status === "unavailable";
+      const result = {
+        ...target,
+        ...observation,
+        checkedAt,
+        durationMs: Date.now() - start,
+        attempts,
+        consecutiveFailures: failed ? (old?.status === "unavailable" ? old.consecutiveFailures : 0) + 1 : 0,
+        firstFailureAt: failed ? old?.status === "unavailable" ? old.firstFailureAt ?? checkedAt : checkedAt : void 0,
+        lastSuccessAt: observation.status === "reachable" ? checkedAt : old?.lastSuccessAt,
+        changed: Boolean(old && (old.status !== observation.status || old.finalUrl !== observation.finalUrl)),
+        recovered: observation.status === "reachable" && old?.status === "unavailable"
+      };
+      results[index] = result;
+      await options.onResult?.(result);
+    }
+  }));
+  const summary = { total: results.length, reachable: 0, restricted: 0, unavailable: 0, redirected: 0, recovered: 0 };
+  for (const result of results) {
+    summary[result.status]++;
+    summary.redirected += Number(result.redirects.length > 0);
+    summary.recovered += Number(result.recovered);
+  }
+  return { schemaVersion: 1, observer, startedAt, completedAt: (/* @__PURE__ */ new Date()).toISOString(), summary, results };
+}
+
+function planReporters(config, options = {}) {
+  const entries = typeof config === "string" ? [config] : config;
+  if (!Array.isArray(entries))
+    throw new TypeError("reporter must be a name or an array of names / [name, options] tuples.");
+  const cwd = options.cwd ?? process__default.cwd();
+  const output = path.resolve(cwd, options.outputDir ?? "reports/meodp");
+  const path$1 = (value) => {
+    if (typeof value !== "string" || !value.trim() || value.includes("\0"))
+      throw new TypeError("Reporter output paths must be nonempty strings.");
+    return path.resolve(cwd, value);
+  };
+  const planned = entries.map((entry) => {
+    if (typeof entry !== "string" && (!Array.isArray(entry) || entry.length < 1 || entry.length > 2))
+      throw new TypeError("Each reporter must be a name or [name, options] tuple.");
+    const [name, settings = {}] = typeof entry === "string" ? [entry] : entry;
+    if (!["json", "markdown", "html"].includes(name))
+      throw new TypeError(`Unknown reporter ${JSON.stringify(name)}; use json, markdown, or html.`);
+    if (!settings || typeof settings !== "object" || Array.isArray(settings))
+      throw new TypeError("Reporter options must be an object.");
+    const allowed = name === "html" ? ["outputFile", "outputFolder", "dataUrl"] : ["outputFile"];
+    for (const key of Object.keys(settings)) {
+      if (!allowed.includes(key))
+        throw new TypeError(`Unknown ${name} reporter option: ${key}`);
+    }
+    const file = "outputFile" in settings && settings.outputFile !== void 0 ? path$1(settings.outputFile) : void 0;
+    if (name !== "html")
+      return { reporter: name, file: file ?? path.join(output, name === "json" ? "report.json" : "report.md") };
+    const folder = "outputFolder" in settings && settings.outputFolder !== void 0 ? path$1(settings.outputFolder) : void 0;
+    if (file && folder)
+      throw new TypeError("HTML reporter accepts either outputFile or outputFolder, not both.");
+    const dataUrl = ("dataUrl" in settings ? settings.dataUrl : void 0) ?? options.dataUrl;
+    if (dataUrl !== void 0 && typeof dataUrl !== "string")
+      throw new TypeError("HTML reporter dataUrl must be a string.");
+    if (dataUrl !== void 0)
+      report.createReportHtml(void 0, { dataUrl });
+    return { reporter: name, file: file ?? path.join(folder ?? output, "index.html"), json: file ? void 0 : path.join(folder ?? output, "report.json"), dataUrl };
+  });
+  const outputs = /* @__PURE__ */ new Map();
+  for (const item of planned) {
+    for (const [file, kind] of [[item.file, item.reporter], [item.json, "json"]]) {
+      if (!file)
+        continue;
+      const existing = outputs.get(file);
+      if (existing && (existing !== "json" || kind !== "json"))
+        throw new TypeError(`Reporter outputs collide at ${file}`);
+      outputs.set(file, kind);
+    }
+  }
+  for (const file of outputs.keys()) {
+    let parent = path.dirname(file);
+    while (parent !== path.dirname(parent)) {
+      if (outputs.has(parent))
+        throw new TypeError(`Reporter output is also used as a directory: ${parent}`);
+      parent = path.dirname(parent);
+    }
+  }
+  return planned;
+}
+async function writeReporters(report$1, reporter, options = {}) {
+  const plan = planReporters(reporter, options);
+  if (report$1)
+    report$1 = report.parseReport(report$1);
+  if (!report$1 && plan.some((item) => item.reporter !== "html"))
+    throw new TypeError("JSON and Markdown reporters require an input report.");
+  const writes = /* @__PURE__ */ new Map();
+  const outputs = plan.map((item) => {
+    const files = [item.file];
+    if (item.reporter === "html") {
+      writes.set(item.file, report.createReportHtml(report$1, { dataUrl: item.dataUrl ?? (report$1 && item.json ? "./report.json" : void 0) }));
+      if (report$1 && item.json) {
+        writes.set(item.json, report.formatReport(report$1, "json"));
+        files.push(item.json);
+      }
+    } else {
+      writes.set(item.file, report.formatReport(report$1, item.reporter));
+    }
+    return { reporter: item.reporter, files };
+  });
+  for (const [file, content] of writes) {
+    await promises$1.mkdir(path.dirname(file), { recursive: true });
+    await promises$1.writeFile(file, content);
+  }
+  return outputs;
+}
+
+const unzip = node_util.promisify(node_zlib.gunzip);
+class DocumentError extends Error {
+  constructor(message, retryable = false) {
+    super(message);
+    this.retryable = retryable;
+  }
+}
+function discoveryOptions(options) {
+  const normalized = normalizeCheckOptions(options);
+  if (options.discover !== void 0 && typeof options.discover !== "boolean")
+    throw new TypeError("discover must be a boolean");
+  return {
+    ...normalized,
+    maxUrls: integerOption(options.maxUrls, 1e4, "maxUrls", 1, 5e4),
+    maxSitemaps: integerOption(options.maxSitemaps, 100, "maxSitemaps", 1, 1e4),
+    maxSitemapBytes: integerOption(options.maxSitemapBytes, 10 * 1024 * 1024, "maxSitemapBytes", 1, 100 * 1024 * 1024)
+  };
+}
+async function readDocument(source, options, allowMissing = false) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      let url = source;
+      const visited = /* @__PURE__ */ new Set();
+      for (; ; ) {
+        visited.add(url);
+        const response = await fetch(url, {
+          redirect: "manual",
+          signal: AbortSignal.timeout(options.timeoutMs)
+        });
+        if ([301, 302, 303, 307, 308].includes(response.status)) {
+          await response.body?.cancel();
+          const location = response.headers.get("location");
+          let next;
+          try {
+            if (!location)
+              throw new Error("Missing location");
+            next = normalizeUrl(new URL(location, url).href);
+          } catch {
+            throw new DocumentError(`Invalid sitemap/robots redirect from ${url}`);
+          }
+          if (visited.has(next) || visited.size > options.maxRedirects)
+            throw new DocumentError(`Sitemap/robots redirect loop or limit exceeded: ${url}`);
+          url = next;
+          continue;
+        }
+        if (!response.ok) {
+          await response.body?.cancel();
+          if (allowMissing && [404, 410].includes(response.status))
+            return void 0;
+          throw new DocumentError(`Unable to read ${url}: HTTP ${response.status}`, response.status >= 500);
+        }
+        const chunks = [];
+        let size = 0;
+        if (response.body) {
+          const reader = response.body.getReader();
+          try {
+            for (; ; ) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              size += value.byteLength;
+              if (size > options.maxSitemapBytes)
+                throw new DocumentError(`Discovery document exceeds maxSitemapBytes: ${url}`);
+              chunks.push(value);
+            }
+          } finally {
+            await reader.cancel().catch(() => {
+            });
+            reader.releaseLock();
+          }
+        }
+        let body = node_buffer.Buffer.concat(chunks);
+        if (body[0] === 31 && body[1] === 139) {
+          try {
+            body = await unzip(body, { maxOutputLength: options.maxSitemapBytes });
+          } catch {
+            throw new DocumentError(`Invalid gzip or decompressed document exceeds maxSitemapBytes: ${url}`);
+          }
+        }
+        return { url, text: body.toString("utf8") };
+      }
+    } catch (error) {
+      if (attempt >= options.retries || error instanceof DocumentError && !error.retryable)
+        throw new Error(`Sitemap discovery failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      await promises.setTimeout(500 * 2 ** attempt);
+    }
+  }
+}
+function parseLocations(text, source) {
+  if (/<!DOCTYPE|<!ENTITY/i.test(text) || fastXmlParser.XMLValidator.validate(text) !== true)
+    throw new Error(`Invalid sitemap XML: ${source}`);
+  const parser = new fastXmlParser.XMLParser({
+    ignoreAttributes: true,
+    removeNSPrefix: true,
+    parseTagValue: false,
+    isArray: (name) => name === "url" || name === "sitemap"
+  });
+  const document = parser.parse(text);
+  const roots = Object.keys(document).filter((key) => !key.startsWith("?"));
+  if (roots.length !== 1 || !["urlset", "sitemapindex"].includes(roots[0]))
+    throw new Error(`Expected a sitemap urlset or sitemapindex: ${source}`);
+  const isIndex = roots[0] === "sitemapindex";
+  const root = document[roots[0]];
+  if (root?.[isIndex ? "url" : "sitemap"])
+    throw new Error(`Mixed sitemap index and page entries: ${source}`);
+  const entries = root?.[isIndex ? "sitemap" : "url"] ?? [];
+  const urls = entries.map((entry) => {
+    if (!entry || typeof entry !== "object" || !("loc" in entry) || typeof entry.loc !== "string" || !entry.loc.trim())
+      throw new Error(`Missing or invalid sitemap loc: ${source}`);
+    try {
+      return normalizeUrl(new URL(entry.loc.trim(), source).href);
+    } catch {
+      throw new Error(`Invalid HTTP(S) URL in sitemap: ${source}`);
+    }
+  });
+  return { isIndex, urls };
+}
+async function readSitemapUrls(source, options = {}) {
+  const input = normalizeUrl(source.trim());
+  const config = discoveryOptions(options);
+  let pending = [input];
+  if (options.discover) {
+    const robots = await readDocument(new URL("/robots.txt", input).href, config, true);
+    const declared = robots?.text.split(/\r?\n/).flatMap((line) => {
+      const match = line.match(/^\s*sitemap\s*:\s*(\S+)/i);
+      return match ? [normalizeUrl(new URL(match[1], robots.url).href)] : [];
+    }) ?? [];
+    pending = declared.length ? declared : [new URL("/sitemap.xml", input).href];
+  }
+  const queued = new Set(pending);
+  pending = [...queued];
+  const visited = /* @__PURE__ */ new Set();
+  const pages = /* @__PURE__ */ new Set();
+  let documentCount = 0;
+  for (let cursor = 0; cursor < pending.length; cursor++) {
+    const url = pending[cursor];
+    if (visited.has(url))
+      continue;
+    if (++documentCount > config.maxSitemaps)
+      throw new Error("Sitemap discovery exceeds maxSitemaps; no pages were checked");
+    visited.add(url);
+    const document = await readDocument(url, config);
+    if (!document)
+      throw new Error(`Unable to read sitemap: ${url}`);
+    visited.add(document.url);
+    const { isIndex, urls } = parseLocations(document.text, document.url);
+    for (const location of urls) {
+      if (isIndex) {
+        if (!queued.has(location) && !visited.has(location)) {
+          queued.add(location);
+          pending.push(location);
+        }
+      } else {
+        pages.add(location);
+        if (pages.size > config.maxUrls)
+          throw new Error("Sitemap discovery exceeds maxUrls; no pages were checked");
+      }
+    }
+  }
+  if (!pages.size)
+    throw new Error("Sitemap discovery found no page URLs; no pages were checked");
+  return [...pages];
+}
+async function checkSitemap(source, options = {}) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const urls = await readSitemapUrls(source, options);
+  const report = await checkLinks(urls, options);
+  return { ...report, startedAt };
+}
+
+async function waitForReport(expected, { url, attempts = 12, delayMs = 15e3 }) {
+  if (!Number.isSafeInteger(attempts) || attempts < 1 || attempts > 120 || !Number.isFinite(delayMs) || delayMs < 0 || delayMs > 3e5)
+    throw new Error("Invalid report verification retry options.");
+  const reportUrl = new URL(url);
+  if (!["https:", "http:"].includes(reportUrl.protocol) || reportUrl.username || reportUrl.password)
+    throw new Error("Report verification requires an HTTP(S) URL without credentials.");
+  reportUrl.searchParams.set("observation", expected.completedAt);
+  const expectedJson = JSON.stringify(report.parseReport(expected));
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      const options = { cache: "no-store", signal: AbortSignal.timeout(1e4) };
+      const response = await fetch(reportUrl, options);
+      if (response.ok && JSON.stringify(report.parseReport(await response.json())) === expectedJson) {
+        const page = await fetch(new URL("./", url), { cache: "no-store", signal: AbortSignal.timeout(1e4) });
+        if (page.ok && (await page.text()).includes('id="meodp-data"'))
+          return;
+      }
+    } catch {
+    }
+    if (attempt + 1 < attempts)
+      await promises.setTimeout(delayMs);
+  }
+  throw new Error("The public status page did not serve this report in time. Check the hosting deployment; saved report files remain available.");
+}
+
+exports.checkLinks = checkLinks;
+exports.checkSitemap = checkSitemap;
+exports.normalizeTargets = normalizeTargets;
+exports.planReporters = planReporters;
+exports.readSitemapUrls = readSitemapUrls;
+exports.waitForReport = waitForReport;
+exports.writeReporters = writeReporters;

package/dist/shared/meodp.f96d0510.mjs

@@ -0,0 +1,24 @@
+import { access } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import process from 'node:process';
+import { loadConfig } from 'c12';
+
+async function loadProjectConfig(file) {
+  if (file)
+    await access(resolve(file));
+  const { config, configFile } = await loadConfig({
+    name: "meodp",
+    cwd: process.cwd(),
+    configFile: file ? resolve(file) : void 0,
+    rcFile: false,
+    globalRc: false,
+    dotenv: false,
+    packageJson: false,
+    extend: false,
+    giget: false
+  });
+  const root = configFile ? dirname(configFile) : process.cwd();
+  return { config, path: (value) => resolve(root, value) };
+}
+
+export { loadProjectConfig as l };