@mulmoclaude/core 1.0.1 → 1.2.1

package/dist/feeds/server/index.js

@@ -1,40 +1,34 @@
-import { c as INGEST_KINDS, s as FEED_SCHEDULES } from "../../ids-D1M1T6KJ.js";
-import { A as buildCollectionActionSeedPrompt, F as promptPathsFor, P as listItems, X as safeSlugName, n as discoverCollections, q as resolveDataDir, u as storeFor, z as readSkillTemplate } from "../../discovery-BYIsLqag.js";
-import "../../server-CtCBLYgZ.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-Ci4eOgv-.js";
+import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../../ids-s4GfmE93.js";
+import { N as listItems, V as resolveDataDir, W as safeSlugName, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../../discovery-CKR4TOX3.js";
+import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-BZJCw2HU.js";
+import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-L59cIGgX.js";
 import { FEEDS_DIR, feedDir, feedStatePath, feedsRoot, ingestStateDir, ingestStatePath } from "../paths.js";
-import { d as publish, n as clear } from "../../notifier-ChpY0XrY.js";
+import { d as publish, n as clear } from "../../notifier-BdA5qzhe.js";
 import path from "node:path";
-import { mkdir, readFile, rm } from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { mkdir, readFile, rm } from "node:fs/promises";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 import { XMLParser } from "fast-xml-parser";
 import { MISSED_RUN_POLICIES, SCHEDULE_TYPES } from "@receptron/task-scheduler";
 //#region src/feeds/server/host.ts
-var current = null;
+var hostSlot = createHostSlot("@mulmoclaude/core/feeds: configureFeedsHost()");
 /** Wire the feeds engine to a host. Call once at startup, before any refresh. */
 function configureFeedsHost(host) {
-	if (current && current !== host) throw new Error("@mulmoclaude/core/feeds: configureFeedsHost() was already called with a different host");
-	current = host;
+	hostSlot.set(host);
 }
 /** The configured host, or throw if `configureFeedsHost` was never called. */
 function requireFeedsHost() {
-	if (!current) throw new Error("@mulmoclaude/core/feeds: configureFeedsHost() was not called by the host");
-	return current;
+	return hostSlot.get();
 }
 /** Test-only: clear the configured host. */
 function resetFeedsHostForTesting() {
-	current = null;
+	hostSlot.reset();
 }
 /** Forwarding logger so engine modules can `import { log }` without each
-*  reaching for `requireFeedsHost().log`. */
-var log = {
-	error: (prefix, msg, data) => requireFeedsHost().log.error(prefix, msg, data),
-	warn: (prefix, msg, data) => requireFeedsHost().log.warn(prefix, msg, data),
-	info: (prefix, msg, data) => requireFeedsHost().log.info(prefix, msg, data),
-	debug: (prefix, msg, data) => requireFeedsHost().log.debug(prefix, msg, data)
-};
+*  reaching for `requireFeedsHost().log`. Non-critical: calls before the host
+*  is wired are dropped (not thrown), matching the collection/google seams. */
+var log = createForwardingLogger(() => hostSlot.peek()?.log ?? null);
 //#endregion
 //#region src/feeds/server/registry.ts
 /** Every registered feed, as a discovered collection (carrying its
@@ -84,69 +78,156 @@ function getRetriever(kind) {
 	return registry.get(kind);
 }
 //#endregion
-//#region src/feeds/server/fetch/httpClient.ts
-var ONE_SECOND_MS = 1e3;
-/** Identifies the bot to site operators. */
-var FEED_USER_AGENT = "MulmoClaude-FeedBot/1.0 (+https://github.com/receptron/mulmoclaude)";
-/** Per-request wall-clock cap so a hung server can't wedge a refresh. */
-var DEFAULT_FEED_TIMEOUT_MS = 30 * ONE_SECOND_MS;
-/** Cap on redirect hops followed (each re-checked for SSRF). */
-var MAX_REDIRECTS = 5;
-var BLOCKED_V4_CIDRS = [
+//#region ../common/dist/ssrf.js
+var ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+	"localhost",
+	"ip6-localhost",
+	"ip6-loopback"
+]);
+var BLOCKED_HOSTNAME_SUFFIXES = [
+	".localhost",
+	".local",
+	".internal"
+];
+/** IPv4 ranges that must never be fetched, as [firstAddress, prefixLength].
+*  The union of the pre-#2459 per-guard tables — removing an entry weakens
+*  every guard in the repo at once, so treat edits as security changes. */
+var BLOCKED_IPV4_RANGES = [
 	["0.0.0.0", 8],
 	["10.0.0.0", 8],
 	["100.64.0.0", 10],
 	["127.0.0.0", 8],
 	["169.254.0.0", 16],
 	["172.16.0.0", 12],
-	["192.168.0.0", 16]
+	["192.0.0.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
 ];
+/** Dotted-decimal IPv4 → unsigned 32-bit value; null for anything else
+*  (hex / octal octets, whitespace, wrong part count). */
 function ipv4ToInt(address) {
-	const octets = address.split(".").map(Number);
-	if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return null;
-	return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+	const parts = address.split(".");
+	if (parts.length !== 4) return null;
+	const octets = parts.map((part) => /^\d{1,3}$/.test(part) ? Number(part) : NaN);
+	if (octets.some((octet) => Number.isNaN(octet) || octet > 255)) return null;
+	return octets.reduce((value, octet) => value * 256 + octet, 0);
+}
+function isBlockedIpv4Value(value) {
+	return BLOCKED_IPV4_RANGES.some(([base, prefix]) => {
+		const baseValue = ipv4ToInt(base);
+		if (baseValue === null) return false;
+		const mask = prefix === 0 ? 0 : -1 << 32 - prefix >>> 0;
+		return (value & mask) === (baseValue & mask);
+	});
 }
+/** True when this parses as IPv4 AND falls inside a blocked range. Non-IPv4
+*  input is false — "not a blocked literal", not "safe"; a caller that must
+*  reject non-IP input entirely does so at its own boundary. */
 function isBlockedIpv4(address) {
 	const value = ipv4ToInt(address);
-	if (value === null) return true;
-	return BLOCKED_V4_CIDRS.some(([base, bits]) => {
-		const baseInt = ipv4ToInt(base) ?? 0;
-		const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
-		return (value & mask) === (baseInt & mask);
-	});
+	if (value === null) return false;
+	return isBlockedIpv4Value(value);
+}
+/** `URL.hostname` keeps the brackets on an IPv6 literal (`[::1]`); strip them
+*  so the address checks see the bare address. */
+function stripIpv6Brackets(hostname) {
+	return hostname.replace(/^\[|\]$/g, "");
+}
+/** The 32-bit value inside an IPv4-mapped IPv6 literal, or null when the
+*  address is not v4-mapped. The hex spelling matters: WHATWG URL serializes
+*  `[::ffff:127.0.0.1]` as `::ffff:7f00:1`, so matching only the dotted form
+*  would wave the mapped loopback through any URL-sourced check. */
+function mappedIpv4Value(lower) {
+	const dotted = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+	if (dotted) return ipv4ToInt(dotted[1]);
+	const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(lower);
+	if (hex) return Number.parseInt(hex[1], 16) * 65536 + Number.parseInt(hex[2], 16);
+	return null;
 }
+/** Blocks loopback/unspecified, fc00::/7 unique-local, fe80::/10 link-local,
+*  and IPv4-mapped forms of blocked v4 addresses. Mask-based on the leading
+*  group — prefix string matching would miss e.g. fe9a:: (inside fe80::/10). */
 function isBlockedIpv6(address) {
-	const lower = address.toLowerCase();
+	const lower = stripIpv6Brackets(address.toLowerCase());
 	if (lower === "::1" || lower === "::") return true;
-	if (lower.startsWith("fe80")) return true;
-	if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
-	const mapped = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(lower);
-	return mapped ? isBlockedIpv4(mapped[1]) : false;
-}
-/** True for any address we must not fetch (also blocks non-IP input). */
+	const mapped = mappedIpv4Value(lower);
+	if (mapped !== null) return isBlockedIpv4Value(mapped);
+	const [head] = lower.split(":");
+	if (head.length === 0) return false;
+	const leading = Number.parseInt(head, 16);
+	if (Number.isNaN(leading)) return false;
+	if ((leading & 65024) === 64512) return true;
+	if ((leading & 65472) === 65152) return true;
+	return false;
+}
+/** True when this literal address must never be fetched. Non-IP input is
+*  false — see `isBlockedIpv4`. */
 function isBlockedIp(address) {
+	return address.includes(":") ? isBlockedIpv6(address) : isBlockedIpv4(address);
+}
+/** Names that are internal by convention (localhost, *.local, *.internal…),
+*  rejected without waiting for DNS to prove it. */
+function isBlockedHostname(hostname) {
+	const lower = hostname.toLowerCase().replace(/\.$/, "");
+	if (BLOCKED_HOSTNAMES.has(lower)) return true;
+	return BLOCKED_HOSTNAME_SUFFIXES.some((suffix) => lower.endsWith(suffix));
+}
+function parseUrl(raw) {
+	try {
+		return new URL(raw);
+	} catch {
+		return null;
+	}
+}
+/** Parse and apply every check that doesn't need the network: shape, scheme,
+*  obviously-internal hostname, and literal addresses. Returns null on reject.
+*  Callers must still vet what non-literal hostnames resolve to. */
+function parseSafeUrlShape(raw) {
+	const url = parseUrl(raw);
+	if (url === null) return null;
+	if (!ALLOWED_PROTOCOLS.has(url.protocol)) return null;
+	const hostname = stripIpv6Brackets(url.hostname);
+	if (hostname.length === 0) return null;
+	if (isBlockedHostname(hostname)) return null;
+	if (isBlockedIp(hostname)) return null;
+	return url;
+}
+//#endregion
+//#region src/feeds/server/fetch/httpClient.ts
+var ONE_SECOND_MS = 1e3;
+/** Identifies the bot to site operators. */
+var FEED_USER_AGENT = "MulmoClaude-FeedBot/1.0 (+https://github.com/receptron/mulmoclaude)";
+/** Per-request wall-clock cap so a hung server can't wedge a refresh. */
+var DEFAULT_FEED_TIMEOUT_MS = 30 * ONE_SECOND_MS;
+/** Cap on redirect hops followed (each re-checked for SSRF). */
+var MAX_REDIRECTS = 5;
+/** DNS answers should be IP literals; anything else is blocked outright. */
+function isBlockedResolvedIp(address) {
 	const kind = isIP(address);
 	if (kind === 4) return isBlockedIpv4(address);
 	if (kind === 6) return isBlockedIpv6(address);
 	return true;
 }
-/** Reject non-http(s) URLs and URLs that resolve to a private/loopback
-*  address (SSRF guard). Throws with a clear reason; returns void on pass. */
-async function assertFetchableUrl(rawUrl) {
-	if (!/^https?:\/\//i.test(rawUrl)) throw new Error(`refusing non-http(s) URL: ${rawUrl}`);
-	const { hostname } = new URL(rawUrl);
-	const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-	if (isIP(host)) {
-		if (isBlockedIp(host)) throw new Error(`refusing to fetch a private/loopback address: ${host}`);
-		return;
-	}
-	let addresses;
+async function resolveAddresses(host) {
 	try {
-		addresses = await lookup(host, { all: true });
+		return await lookup(host, { all: true });
 	} catch (err) {
 		throw new Error(`could not resolve host '${host}': ${String(err)}`);
 	}
-	const blocked = addresses.find((entry) => isBlockedIp(entry.address));
+}
+/** Reject non-http(s) URLs, internal-by-convention hostnames, and URLs whose
+*  host is / resolves to a private/loopback address (SSRF guard). Throws with
+*  a clear reason; returns void on pass. */
+async function assertFetchableUrl(rawUrl) {
+	if (!/^https?:\/\//i.test(rawUrl)) throw new Error(`refusing non-http(s) URL: ${rawUrl}`);
+	const url = parseSafeUrlShape(rawUrl);
+	if (url === null) throw new Error(`refusing to fetch a private/loopback/internal address: ${rawUrl}`);
+	const host = stripIpv6Brackets(url.hostname);
+	if (isIP(host)) return;
+	const blocked = (await resolveAddresses(host)).find((entry) => isBlockedResolvedIp(entry.address));
 	if (blocked) throw new Error(`refusing to fetch '${host}' — resolves to a private/loopback address (${blocked.address})`);
 }
 async function fetchOnce(url, timeoutMs) {
@@ -305,7 +386,8 @@ function step(current, token) {
 	if (current === null || current === void 0) return void 0;
 	if (token.kind === "key") {
 		if (typeof current !== "object" || Array.isArray(current)) return void 0;
-		return current[token.key];
+		const record = current;
+		return Object.hasOwn(record, token.key) ? record[token.key] : void 0;
 	}
 	return Array.isArray(current) ? current[token.index] : void 0;
 }