@mcptoolshop/claude-synergy 1.1.0 → 1.2.0

package/dist/chunk-X25ZTSCJ.js

@@ -0,0 +1,1150 @@
+import {
+  loadProductsConfig
+} from "./chunk-MZLFGICO.js";
+
+// src/fetch.ts
+import { execFileSync } from "child_process";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
+import { join as join2, resolve } from "path";
+
+// src/fetch-rss.ts
+import { XMLParser } from "fast-xml-parser";
+
+// src/fetch-utils.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var GITHUB_TOKEN_HINT = "GitHub API rate limit hit. Set GITHUB_TOKEN env var for 5000 req/hr (vs 60 unauthenticated).";
+async function fetchWithRetry(url, opts = {}) {
+  const {
+    timeoutMs = 3e4,
+    maxRetries = 3,
+    baseDelayMs = 1e3,
+    signal: externalSignal,
+    ...fetchInit
+  } = opts;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (externalSignal?.aborted) {
+      throw new Error(`fetch aborted: ${externalSignal.reason?.message ?? "signal aborted"}`);
+    }
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = externalSignal ? AbortSignal.any([timeoutSignal, externalSignal]) : timeoutSignal;
+    try {
+      const res = await fetch(url, {
+        ...fetchInit,
+        signal: combinedSignal
+      });
+      if (res.ok) return res;
+      if (!RETRYABLE_STATUSES.has(res.status)) {
+        if (res.status === 403 && isGitHubApiUrl(url)) {
+          throw new Error(`HTTP 403 from ${url} \u2014 ${GITHUB_TOKEN_HINT}`);
+        }
+        return res;
+      }
+      if (attempt < maxRetries) {
+        const delay = computeDelay(res, attempt, baseDelayMs);
+        console.error(
+          `[retry] ${fetchInit.method ?? "GET"} ${String(url)} (attempt ${attempt + 2}/${maxRetries + 1}, status ${res.status}, backoff ${delay}ms)`
+        );
+        await sleep(delay, externalSignal);
+        continue;
+      }
+      const ghHint = res.status === 429 && isGitHubApiUrl(url) ? ` ${GITHUB_TOKEN_HINT}` : "";
+      throw new Error(`HTTP ${res.status} from ${url} after ${maxRetries + 1} attempts.${ghHint}`);
+    } catch (e) {
+      if (externalSignal?.aborted) {
+        throw new Error(`fetch aborted: ${externalSignal.reason?.message ?? "signal aborted"}`);
+      }
+      lastError = e;
+      if (attempt < maxRetries) {
+        const delay = computeDelay(null, attempt, baseDelayMs);
+        console.error(
+          `[retry] ${fetchInit.method ?? "GET"} ${String(url)} (attempt ${attempt + 2}/${maxRetries + 1}, ${e.name ?? "Error"}: ${e.message}, backoff ${delay}ms)`
+        );
+        try {
+          await sleep(delay, externalSignal);
+        } catch {
+          throw e;
+        }
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw lastError ?? new Error(`fetchWithRetry: unexpected exhaustion for ${url}`);
+}
+function computeDelay(res, attempt, baseDelayMs) {
+  if (res) {
+    const retryAfter = res.headers.get("retry-after");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (!Number.isNaN(seconds) && seconds > 0) {
+        return Math.min(seconds * 1e3, 6e4);
+      }
+      const date = new Date(retryAfter);
+      if (!Number.isNaN(date.getTime())) {
+        const delayMs = date.getTime() - Date.now();
+        if (delayMs > 0) return Math.min(delayMs, 6e4);
+      }
+    }
+  }
+  const exponential = baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * baseDelayMs * 0.5;
+  return Math.min(exponential + jitter, 3e4);
+}
+function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.reject(new Error("sleep interrupted: signal already aborted"));
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error("sleep interrupted: signal aborted"));
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isGitHubApiUrl(url) {
+  try {
+    const hostname = typeof url === "string" ? new URL(url).hostname : url.hostname;
+    return hostname === "api.github.com" || hostname === "raw.githubusercontent.com";
+  } catch {
+    const s = String(url);
+    return s.includes("api.github.com") || s.includes("raw.githubusercontent.com");
+  }
+}
+var DEFAULT_FETCH_ALL_TIMEOUT_MS = 5 * 60 * 1e3;
+function createFetchAllController(timeoutMs = DEFAULT_FETCH_ALL_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(new Error(`fetchAll global timeout exceeded (${timeoutMs}ms)`));
+  }, timeoutMs);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  return { controller, signal: controller.signal };
+}
+
+// src/fetch-rss.ts
+async function fetchRssReleases(url, sinceIso, titleFilter, signal) {
+  const res = await fetchWithRetry(url, {
+    headers: { "user-agent": "claude-synergy/0.1.0" },
+    signal
+  });
+  if (!res.ok) throw new Error(`RSS ${url} returned ${res.status}`);
+  const xml = await res.text();
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    cdataPropName: "__cdata",
+    parseTagValue: false,
+    trimValues: true
+  });
+  const parsed = parser.parse(xml);
+  const rawItems = parsed?.rss?.channel?.item ?? [];
+  const items = Array.isArray(rawItems) ? rawItems : [rawItems];
+  const out = [];
+  for (const it of items) {
+    if (!it) continue;
+    const title = pickString(it.title);
+    if (titleFilter && title && !titleFilter.test(title)) continue;
+    const link = pickString(it.link) ?? pickString(it.guid) ?? "";
+    const pubDateRaw = pickString(it.pubDate) ?? pickString(it["dc:date"]) ?? "";
+    const pubDateIso = parsePubDate(pubDateRaw);
+    if (!pubDateIso) continue;
+    if (pubDateIso <= sinceIso) continue;
+    const guid = pickString(it.guid) ?? link;
+    const slug = makeSlug(guid, pubDateIso, title);
+    const body = pickString(it["content:encoded"]) ?? pickString(it.description) ?? null;
+    out.push({ slug, title, link, pubDate: pubDateIso, body });
+  }
+  return out;
+}
+function pickString(v) {
+  if (v == null) return null;
+  if (typeof v === "string") return v.trim() || null;
+  if (typeof v === "object") {
+    const o = v;
+    if (typeof o.__cdata === "string") return o.__cdata.trim() || null;
+    if (typeof o["#text"] === "string") return o["#text"].trim() || null;
+    if (typeof o.toString === "function") {
+      const s = String(v);
+      if (s !== "[object Object]") return s.trim() || null;
+    }
+  }
+  return null;
+}
+function parsePubDate(raw) {
+  if (!raw) return null;
+  const d = new Date(raw);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString();
+}
+function makeSlug(guid, isoDate, title) {
+  try {
+    const u = new URL(guid);
+    const parts = u.pathname.split("/").filter(Boolean);
+    const last = parts[parts.length - 1];
+    if (last && /^[a-z0-9][a-z0-9._-]*$/i.test(last)) {
+      return last.replace(/\.html?$/, "").toLowerCase();
+    }
+  } catch {
+  }
+  const date = isoDate.split("T")[0];
+  if (title) {
+    const titleSlug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+    return `${date}-${titleSlug}`;
+  }
+  return date;
+}
+
+// src/fetch-changelog.ts
+import { execSync } from "child_process";
+async function fetchAiderHistory(url, sinceIso, signal) {
+  const res = await fetchWithRetry(url, {
+    headers: { "user-agent": "claude-synergy/0.1.0" },
+    signal
+  });
+  if (!res.ok) throw new Error(`raw-changelog ${url} returned ${res.status}`);
+  const md = await res.text();
+  const items = parseAiderHistory(md);
+  const releaseDates = aiderReleaseDates();
+  for (const item of items) {
+    const tag = `v${item.version}`;
+    if (releaseDates.has(tag)) {
+      item.releasedAt = releaseDates.get(tag);
+    }
+  }
+  return items.filter((i) => !i.releasedAt || i.releasedAt > sinceIso);
+}
+function parseAiderHistory(md) {
+  const lines = md.split("\n");
+  const out = [];
+  let currentVersion = null;
+  let currentBody = [];
+  const flush = () => {
+    if (currentVersion) {
+      out.push({
+        version: currentVersion,
+        releasedAt: null,
+        body: currentBody.join("\n").trim()
+      });
+    }
+    currentBody = [];
+  };
+  for (const line of lines) {
+    const headerMatch = line.match(/^###\s+(?:Aider\s+)?(?:v(\d+\.\d+\.\d+(?:[-.][\w.]+)?)|main\s+branch)\s*$/i);
+    if (headerMatch) {
+      flush();
+      currentVersion = headerMatch[1] ?? "main";
+      continue;
+    }
+    if (currentVersion) currentBody.push(line);
+  }
+  flush();
+  return out.filter((i) => i.body.length > 0 || i.version !== "main");
+}
+async function fetchKeepAChangelog(url, sinceIso, signal) {
+  const res = await fetchWithRetry(url, {
+    headers: { "user-agent": "claude-synergy/0.1.0" },
+    signal
+  });
+  if (!res.ok) throw new Error(`raw-changelog ${url} returned ${res.status}`);
+  const md = await res.text();
+  const items = parseKeepAChangelog(md);
+  return items.filter((i) => i.releasedAt !== null && i.releasedAt > sinceIso);
+}
+function parseKeepAChangelog(md) {
+  const lines = md.split(/\r?\n/);
+  const out = [];
+  const versionLineRe = /^##\s+(?:\[\s*)?(v?\d[\w.+\-]*?)(?:\s*\])?\s*(?:[-–(]\s*(\d{4}-\d{2}-\d{2})\s*\)?)?\s*$/i;
+  let currentVersion = null;
+  let currentDate = null;
+  let currentBody = [];
+  const flush = () => {
+    if (!currentVersion) return;
+    out.push({
+      version: currentVersion,
+      releasedAt: currentDate,
+      body: currentBody.join("\n").trim()
+    });
+    currentVersion = null;
+    currentDate = null;
+    currentBody = [];
+  };
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      const match = line.match(versionLineRe);
+      if (match) {
+        flush();
+        currentVersion = match[1].replace(/^v/i, "");
+        currentDate = match[2] ?? null;
+        continue;
+      }
+      flush();
+      continue;
+    }
+    if (currentVersion) currentBody.push(line);
+  }
+  flush();
+  return out.filter((i) => i.body.length > 0);
+}
+function aiderReleaseDates() {
+  try {
+    const out = execSync(`gh api "repos/Aider-AI/aider/releases?per_page=100"`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const releases = JSON.parse(out);
+    const map = /* @__PURE__ */ new Map();
+    for (const r of releases) if (r.tag_name && r.published_at) map.set(r.tag_name, r.published_at);
+    return map;
+  } catch (e) {
+    const stderr = (e?.stderr ?? "").toString();
+    if (stderr.includes("403") || stderr.includes("429") || stderr.includes("rate limit")) {
+      console.error(
+        "[claude-synergy] GitHub API rate limit hit while fetching aider release dates. Set GITHUB_TOKEN env var for 5000 req/hr (vs 60 unauthenticated)."
+      );
+    }
+    return /* @__PURE__ */ new Map();
+  }
+}
+
+// src/fetch-html.ts
+import * as cheerio from "cheerio";
+var UA = { "user-agent": "claude-synergy/0.1.0" };
+async function fetchGithubCopilotBlog(sinceIso, signal) {
+  const baseUrl = "https://github.blog/changelog/label/copilot/";
+  const entryUrls = /* @__PURE__ */ new Set();
+  for (let page = 1; page <= 3; page++) {
+    const url = page === 1 ? baseUrl : `${baseUrl}page/${page}/`;
+    try {
+      const res = await fetchWithRetry(url, { headers: UA, signal });
+      if (!res.ok) break;
+      const html = await res.text();
+      const $ = cheerio.load(html);
+      $('a[href*="/changelog/"]').each((_, el) => {
+        const href = $(el).attr("href");
+        if (!href) return;
+        const m = href.match(/^(?:https:\/\/github\.blog)?(\/changelog\/20\d{2}-\d{2}-\d{2}-[^/?#]+\/?)$/);
+        if (m) entryUrls.add(`https://github.blog${m[1].startsWith("/") ? m[1] : "/" + m[1]}`);
+      });
+    } catch {
+      break;
+    }
+  }
+  const items = [];
+  for (const url of entryUrls) {
+    const slugMatch = url.match(/\/changelog\/(20\d{2}-\d{2}-\d{2})-([^/]+)\/?$/);
+    if (!slugMatch) continue;
+    const dateStr = slugMatch[1];
+    const pubDate = (/* @__PURE__ */ new Date(`${dateStr}T12:00:00Z`)).toISOString();
+    if (pubDate <= sinceIso) continue;
+    try {
+      const res = await fetchWithRetry(url, { headers: UA, signal });
+      if (!res.ok) continue;
+      const html = await res.text();
+      const $ = cheerio.load(html);
+      const title = ($("h1").first().text() || $('meta[property="og:title"]').attr("content") || "").trim();
+      const bodyEl = $("article").first();
+      const body = (bodyEl.length ? bodyEl.html() : $("main").first().html()) ?? "";
+      items.push({
+        slug: `${dateStr}-${slugMatch[2]}`,
+        title,
+        pubDate,
+        link: url,
+        body: body.trim()
+      });
+    } catch {
+      continue;
+    }
+  }
+  return items;
+}
+async function fetchWindsurfChangelog(sinceIso, signal) {
+  const url = "https://windsurf.com/changelog";
+  const res = await fetchWithRetry(url, { headers: UA, signal });
+  if (!res.ok) throw new Error(`Windsurf ${res.status}`);
+  const html = await res.text();
+  const $ = cheerio.load(html);
+  const nextDataScript = $("script#__NEXT_DATA__").html();
+  if (!nextDataScript) {
+    console.error("[fetch-html] windsurf: __NEXT_DATA__ not found; changelog is client-rendered. Use the playwright strategy (src/fetch-playwright.ts) for full coverage. 0 entries.");
+    return [];
+  }
+  try {
+    const data = JSON.parse(nextDataScript);
+    const entries = findChangelogEntries(data);
+    if (!entries || entries.length === 0) {
+      console.error("[fetch-html] windsurf: __NEXT_DATA__ present but no entry array found. 0 entries.");
+      return [];
+    }
+    const items = [];
+    for (const e of entries) {
+      const title = (e.title ?? e.heading ?? e.name ?? "").toString().trim();
+      const dateRaw = (e.date ?? e.publishedAt ?? e.published_at ?? "").toString();
+      if (!title || !dateRaw) continue;
+      const d = new Date(dateRaw);
+      if (Number.isNaN(d.getTime())) continue;
+      const pubDate = d.toISOString();
+      if (pubDate <= sinceIso) continue;
+      const body = (e.body ?? e.content ?? e.description ?? "").toString();
+      const titleSlug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+      const slug = `${pubDate.split("T")[0]}-${titleSlug || "entry"}`;
+      items.push({ slug, title, pubDate, link: `${url}#${titleSlug}`, body });
+    }
+    return items;
+  } catch (e) {
+    console.error(`[fetch-html] windsurf: __NEXT_DATA__ parse failed: ${e.message}`);
+    return [];
+  }
+}
+function findChangelogEntries(obj, depth = 0) {
+  if (depth > 8 || !obj || typeof obj !== "object") return null;
+  if (Array.isArray(obj)) {
+    if (obj.length > 0 && typeof obj[0] === "object" && obj[0] !== null && (typeof obj[0].title === "string" || typeof obj[0].heading === "string") && (typeof obj[0].date === "string" || typeof obj[0].publishedAt === "string" || typeof obj[0].published_at === "string")) {
+      return obj;
+    }
+    return null;
+  }
+  for (const v of Object.values(obj)) {
+    const found = findChangelogEntries(v, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+var VSCODE_V_TO_MONTH = {
+  // version → [year, month-1 (0-indexed)]
+  100: [2025, 3],
+  // April 2025
+  101: [2025, 4],
+  // May 2025
+  102: [2025, 5],
+  // June 2025
+  103: [2025, 6],
+  // July 2025
+  104: [2025, 7],
+  // August 2025
+  105: [2025, 8],
+  // September 2025
+  106: [2025, 9],
+  // October 2025
+  107: [2025, 10],
+  // November 2025
+  108: [2025, 11],
+  // December 2025
+  109: [2026, 0],
+  // January 2026
+  110: [2026, 1],
+  // February 2026
+  111: [2026, 2],
+  // March 2026
+  112: [2026, 3],
+  // April 2026
+  113: [2026, 4],
+  // May 2026
+  114: [2026, 5],
+  // June 2026 (future / Insiders)
+  115: [2026, 6],
+  // July 2026 (future / Insiders)
+  116: [2026, 7],
+  117: [2026, 8],
+  118: [2026, 9],
+  119: [2026, 10],
+  120: [2026, 11]
+};
+function parseVscodeReleaseDate(html, $) {
+  const releaseDateMatch = html.match(
+    /Release\s+date[:\s]*((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2},\s*\d{4})/i
+  );
+  if (releaseDateMatch) {
+    const d = new Date(releaseDateMatch[1]);
+    if (!Number.isNaN(d.getTime())) return d.toISOString();
+  }
+  const timeEl = $("time[datetime]").first();
+  if (timeEl.length) {
+    const iso = timeEl.attr("datetime");
+    if (iso) {
+      const d = new Date(iso);
+      if (!Number.isNaN(d.getTime())) return d.toISOString();
+    }
+  }
+  const welcomeMatch = html.match(
+    /Welcome to the\s+((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{4})/i
+  );
+  if (welcomeMatch) {
+    const d = /* @__PURE__ */ new Date(`${welcomeMatch[1]} 15`);
+    if (!Number.isNaN(d.getTime())) return d.toISOString();
+  }
+  return null;
+}
+async function fetchVscodeUpdates(sinceIso, signal) {
+  const items = [];
+  for (const [vStr, [year, monthIdx]] of Object.entries(VSCODE_V_TO_MONTH)) {
+    const v = parseInt(vStr, 10);
+    const fallbackIsoDate = new Date(Date.UTC(year, monthIdx, 15, 12)).toISOString();
+    const versionTag = `v1_${v}`;
+    const url = `https://code.visualstudio.com/updates/${versionTag}`;
+    const fallbackPlus31d = new Date(Date.parse(fallbackIsoDate) + 31 * 24 * 3600 * 1e3).toISOString();
+    if (fallbackPlus31d <= sinceIso) continue;
+    try {
+      const res = await fetchWithRetry(url, { headers: UA, signal, maxRetries: 1 });
+      if (res.status === 404) continue;
+      if (!res.ok) continue;
+      const html = await res.text();
+      const $ = cheerio.load(html);
+      let isoDate = parseVscodeReleaseDate(html, $);
+      if (!isoDate) {
+        console.warn(
+          `[fetch-html] vscode ${versionTag}: no Release-date line found; falling back to mid-month (${fallbackIsoDate.split("T")[0]})`
+        );
+        isoDate = fallbackIsoDate;
+      }
+      if (isoDate <= sinceIso) continue;
+      const title = $("h1").first().text().trim() || `Visual Studio Code 1.${v}`;
+      const body = ($("main").first().html() || $("article").first().html() || "").trim();
+      if (body.length < 200) continue;
+      items.push({
+        slug: versionTag,
+        title,
+        pubDate: isoDate,
+        link: url,
+        body
+      });
+    } catch {
+      continue;
+    }
+  }
+  return items;
+}
+async function fetchHtmlReleases(parser, sinceIso, signal) {
+  switch (parser) {
+    case "github-copilot-blog":
+      return fetchGithubCopilotBlog(sinceIso, signal);
+    case "windsurf-changelog":
+      return fetchWindsurfChangelog(sinceIso, signal);
+    case "vscode-updates":
+      return fetchVscodeUpdates(sinceIso, signal);
+  }
+}
+
+// src/fetch-mcp-registry.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+var UA2 = { "user-agent": "claude-synergy/0.1.0", accept: "application/json" };
+async function fetchOfficialMcpRegistry(opts = {}) {
+  const maxPages = opts.maxPages ?? 50;
+  const limit = 100;
+  let cursor;
+  const byName = /* @__PURE__ */ new Map();
+  for (let page = 0; page < maxPages; page++) {
+    const url = `https://registry.modelcontextprotocol.io/v0/servers?limit=${limit}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+    const res = await fetchWithRetry(url, { headers: UA2, signal: opts.signal });
+    if (!res.ok) throw new Error(`Official MCP Registry ${res.status}`);
+    const json = await res.json();
+    if (!Array.isArray(json.servers)) break;
+    for (const item of json.servers) {
+      const s = item.server;
+      if (!s?.name) continue;
+      const meta = item._meta?.["io.modelcontextprotocol.registry/official"];
+      const isLatest = meta?.isLatest === true;
+      const existing = byName.get(s.name);
+      if (existing && !isLatest) continue;
+      byName.set(s.name, {
+        slug: slugify(s.name),
+        name: s.title ?? s.name,
+        description: (s.description ?? "").trim(),
+        homepage: s.remotes?.[0]?.url ?? null,
+        popularity: null,
+        createdAt: meta?.publishedAt ?? null,
+        source: "official-mcp-registry",
+        category: null,
+        verified: null
+      });
+    }
+    const next = json.metadata?.nextCursor;
+    if (!next || next === cursor) break;
+    cursor = next;
+  }
+  return [...byName.values()];
+}
+async function fetchSmitheryRegistry(opts = {}) {
+  const pageSize = opts.pageSize ?? 100;
+  const maxEntries = opts.maxEntries ?? 200;
+  const out = [];
+  let page = 1;
+  while (out.length < maxEntries) {
+    const url = `https://registry.smithery.ai/servers?page=${page}&pageSize=${pageSize}`;
+    const res = await fetchWithRetry(url, { headers: UA2, signal: opts.signal });
+    if (!res.ok) throw new Error(`Smithery Registry ${res.status}`);
+    const json = await res.json();
+    if (!Array.isArray(json.servers) || json.servers.length === 0) break;
+    for (const s of json.servers) {
+      if (out.length >= maxEntries) break;
+      out.push({
+        slug: slugify(s.qualifiedName ?? s.namespace ?? s.id),
+        name: s.displayName ?? s.qualifiedName,
+        description: (s.description ?? "").trim(),
+        homepage: s.homepage ?? null,
+        popularity: typeof s.useCount === "number" ? s.useCount : null,
+        createdAt: s.createdAt ?? null,
+        source: "smithery",
+        category: null,
+        verified: s.verified ?? null
+      });
+    }
+    const total = json.pagination?.totalPages ?? 1;
+    if (page >= total) break;
+    page++;
+  }
+  out.sort((a, b) => (b.popularity ?? 0) - (a.popularity ?? 0));
+  return out;
+}
+function writeCatalog(productDir, productName, entries) {
+  mkdirSync(productDir, { recursive: true });
+  const catalogPath = join(productDir, "CATALOG.md");
+  const lines = [];
+  lines.push(`# ${productName} \u2014 MCP server catalog`);
+  lines.push("");
+  lines.push(`**Source:** ${entries[0]?.source ?? "unknown"}`);
+  lines.push(`**Entries:** ${entries.length}`);
+  lines.push(`**Fetched:** ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`);
+  lines.push("");
+  lines.push("| Name | Description | Popularity | Created | Homepage |");
+  lines.push("|------|-------------|------------|---------|----------|");
+  for (const e of entries) {
+    const desc = (e.description.split("\n")[0] ?? "").slice(0, 160).replace(/\|/g, "\\|");
+    const pop = e.popularity != null ? String(e.popularity) : "\u2014";
+    const date = e.createdAt ? e.createdAt.split("T")[0] : "\u2014";
+    const home = e.homepage ? `[link](${e.homepage})` : "\u2014";
+    const name = e.name.replace(/\|/g, "\\|");
+    lines.push(`| ${name} | ${desc} | ${pop} | ${date} | ${home} |`);
+  }
+  lines.push("");
+  writeFileSync(catalogPath, lines.join("\n"), "utf-8");
+  return {
+    source: entries[0]?.source ?? "unknown",
+    entriesFetched: entries.length,
+    productDir,
+    catalogPath
+  };
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+}
+async function fetchCatalog(catalogType, opts = {}) {
+  switch (catalogType) {
+    case "official-mcp-registry":
+      return fetchOfficialMcpRegistry({ maxPages: opts.maxPages, signal: opts.signal });
+    case "smithery":
+      return fetchSmitheryRegistry({ maxEntries: opts.maxEntries, signal: opts.signal });
+  }
+}
+
+// src/fetch.ts
+var REPO_PATTERN = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+var PRODUCT_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+function assertRepoShape(repo) {
+  if (!REPO_PATTERN.test(repo)) {
+    throw new Error(
+      `invalid repo: ${JSON.stringify(repo)} \u2014 expected "<org>/<repo>" with safe chars [A-Za-z0-9._-]`
+    );
+  }
+}
+function assertProductShape(product) {
+  if (!PRODUCT_PATTERN.test(product)) {
+    throw new Error(
+      `invalid product name: ${JSON.stringify(product)} \u2014 expected [a-z0-9][a-z0-9-]*`
+    );
+  }
+}
+function sanitizeFilename(s) {
+  const cleaned = s.replace(/[\/\\]/g, "-").replace(/^\.+/, "").replace(/\.\./g, "-").replace(/[<>:"|?*\x00-\x1f]/g, "-").slice(0, 100);
+  if (cleaned.includes("..") || cleaned.includes("/") || cleaned.includes("\\")) {
+    throw new Error(`sanitizeFilename produced unsafe output: ${JSON.stringify(cleaned)}`);
+  }
+  return cleaned;
+}
+function assertSafeFilename(name, context) {
+  if (!name || name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`unsafe filename in ${context}: ${JSON.stringify(name)}`);
+  }
+}
+var HARDCODED_FALLBACK_TARGETS = [
+  // ── Existing Anthropic GH-Releases sources ────────────────────────────────
+  // FE-1: claude-code is the flagship product — wired to gh-releases because the
+  // repo publishes Releases whose bodies mirror CHANGELOG.md but carry real dates.
+  { product: "claude-code", strategy: "gh-releases", repo: "anthropics/claude-code" },
+  { product: "claude-agent-sdk-python", strategy: "gh-releases", repo: "anthropics/claude-agent-sdk-python" },
+  { product: "claude-agent-sdk-typescript", strategy: "gh-releases", repo: "anthropics/claude-agent-sdk-typescript" },
+  { product: "anthropic-cli", strategy: "gh-releases", repo: "anthropics/anthropic-cli" },
+  { product: "anthropic-sdk-python", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-python" },
+  { product: "anthropic-sdk-typescript", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-typescript", multiPackage: true },
+  { product: "anthropic-sdk-go", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-go" },
+  { product: "anthropic-sdk-java", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-java" },
+  { product: "anthropic-sdk-ruby", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-ruby" },
+  { product: "anthropic-sdk-csharp", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-csharp", multiPackage: true },
+  { product: "anthropic-sdk-php", strategy: "gh-releases", repo: "anthropics/anthropic-sdk-php" },
+  { product: "claude-code-action", strategy: "gh-releases", repo: "anthropics/claude-code-action" },
+  { product: "claude-code-security-review", strategy: "gh-releases", repo: "anthropics/claude-code-security-review" },
+  // ── Tier 4a additions ─────────────────────────────────────────────────────
+  // MCP ecosystem SDKs (modelcontextprotocol/*)
+  { product: "mcp-python-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/python-sdk" },
+  { product: "mcp-typescript-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/typescript-sdk", multiPackage: true },
+  { product: "mcp-go-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/go-sdk" },
+  { product: "mcp-java-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/java-sdk" },
+  { product: "mcp-csharp-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/csharp-sdk" },
+  { product: "mcp-kotlin-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/kotlin-sdk" },
+  { product: "mcp-ruby-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/ruby-sdk" },
+  { product: "mcp-swift-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/swift-sdk" },
+  { product: "mcp-rust-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/rust-sdk" },
+  { product: "mcp-php-sdk", strategy: "gh-releases", repo: "modelcontextprotocol/php-sdk" },
+  { product: "mcp-spec", strategy: "gh-releases", repo: "modelcontextprotocol/modelcontextprotocol" },
+  { product: "mcp-inspector", strategy: "gh-releases", repo: "modelcontextprotocol/inspector" },
+  { product: "mcp-registry", strategy: "gh-releases", repo: "modelcontextprotocol/registry" },
+  { product: "mcp-mcpb", strategy: "gh-releases", repo: "modelcontextprotocol/mcpb" },
+  { product: "mcp-conformance", strategy: "gh-releases", repo: "modelcontextprotocol/conformance" },
+  // Continue.dev (multi-platform tagged releases)
+  { product: "continue-dev", strategy: "gh-releases", repo: "continuedev/continue", multiPackage: true },
+  { product: "continue-cli", strategy: "gh-releases", repo: "continuedev/continue-cli" },
+  // RSS-based feeds
+  { product: "cursor", strategy: "rss", rssUrl: "https://cursor.com/changelog/rss.xml" },
+  { product: "cody-enterprise", strategy: "rss", rssUrl: "https://sourcegraph.com/changelog/featured.rss", rssTitleFilter: /cody|sourcegraph/i },
+  // Raw markdown CHANGELOG
+  { product: "aider", strategy: "raw-changelog", rawChangelogUrl: "https://raw.githubusercontent.com/Aider-AI/aider/main/HISTORY.md", rawChangelogParser: "aider-history" },
+  // ── Tier 4b additions — HTML-scraped sources ──────────────────────────────
+  { product: "github-copilot", strategy: "html-scrape", htmlParser: "github-copilot-blog" },
+  { product: "vscode-copilot-chat", strategy: "html-scrape", htmlParser: "vscode-updates" },
+  { product: "windsurf", strategy: "html-scrape", htmlParser: "windsurf-changelog" }
+];
+var TARGETS = loadProductsConfig()?.fetchTargets ?? HARDCODED_FALLBACK_TARGETS;
+async function fetchAll(db, productsRoot, opts = {}) {
+  const targets = opts.product ? TARGETS.filter((t) => t.product === opts.product) : TARGETS;
+  if (targets.length === 0) {
+    throw new Error(`unknown product: ${opts.product} (available: ${TARGETS.map((t) => t.product).join(", ")})`);
+  }
+  const total = targets.length;
+  const onProgress = opts.onProgress;
+  const globalTimeoutMs = opts.timeoutMs ?? DEFAULT_FETCH_ALL_TIMEOUT_MS;
+  const { controller, signal } = createFetchAllController(globalTimeoutMs);
+  const results = [];
+  try {
+    for (let i = 0; i < targets.length; i++) {
+      const target = targets[i];
+      if (signal.aborted) {
+        onProgress?.({ type: "skip", product: target.product, index: i, total, error: "global timeout exceeded" });
+        results.push({
+          product: target.product,
+          fetched: 0,
+          newSince: opts.sinceOverride ?? "",
+          latest: null,
+          errors: ["skipped: global timeout exceeded"]
+        });
+        continue;
+      }
+      onProgress?.({ type: "start", product: target.product, index: i, total });
+      const stats = await fetchOne(db, productsRoot, target, opts.sinceOverride, signal);
+      results.push(stats);
+      if (stats.errors.length > 0) {
+        onProgress?.({ type: "error", product: target.product, index: i, total, error: stats.errors[0] });
+      } else {
+        onProgress?.({ type: "done", product: target.product, index: i, total });
+      }
+    }
+  } finally {
+    controller.abort();
+  }
+  const augmented = results;
+  augmented.summary = buildSummary(results);
+  return augmented;
+}
+function buildSummary(results) {
+  let succeeded = 0;
+  let failed = 0;
+  let skipped = 0;
+  let newChanges = 0;
+  const errors = [];
+  for (const r of results) {
+    const isSkipped = r.errors.some((e) => e.startsWith("skipped:"));
+    const isFailed = r.errors.length > 0 && !isSkipped;
+    if (isSkipped) {
+      skipped++;
+    } else if (isFailed) {
+      failed++;
+      for (const e of r.errors) {
+        errors.push({ product: r.product, error: e });
+      }
+    } else {
+      succeeded++;
+    }
+    newChanges += r.fetched;
+  }
+  return { total: results.length, succeeded, failed, skipped, newChanges, errors };
+}
+async function fetchOne(db, productsRoot, target, sinceOverride, signal) {
+  assertProductShape(target.product);
+  const since = sinceOverride ?? readMarker(db, target.product) ?? "2026-01-01";
+  const outDir = resolve(productsRoot, target.product, "releases");
+  mkdirSync2(outDir, { recursive: true });
+  try {
+    switch (target.strategy) {
+      case "gh-releases":
+        return await fetchGhReleases(db, outDir, target, since);
+      case "rss":
+        return await fetchRss(db, outDir, target, since, signal);
+      case "raw-changelog":
+        return await fetchRawChangelog(db, outDir, target, since, signal);
+      case "html-scrape":
+        return await fetchHtmlScrape(db, outDir, target, since, signal);
+      case "catalog":
+        return await fetchCatalogStrategy(db, productsRoot, target, since, signal);
+      case "playwright":
+        return await fetchPlaywrightStrategy(db, outDir, target, since);
+    }
+  } catch (e) {
+    return {
+      product: target.product,
+      fetched: 0,
+      newSince: since,
+      latest: null,
+      errors: [`fetch failed: ${e.message}`]
+    };
+  }
+}
+async function fetchGhReleases(db, outDir, target, since) {
+  if (!target.repo) throw new Error(`${target.product}: gh-releases strategy requires repo`);
+  const releases = ghReleases(target.repo, since);
+  let latest = null;
+  let fetched = 0;
+  const errors = [];
+  for (const r of releases) {
+    try {
+      const baseName = filenameFor(target, r.tag_name);
+      const filename = sanitizeFilename(baseName);
+      assertSafeFilename(filename, `gh-releases filename for tag ${JSON.stringify(r.tag_name)}`);
+      const vName = sanitizeFilename(`v${baseName}`);
+      assertSafeFilename(vName, `gh-releases vName for tag ${JSON.stringify(r.tag_name)}`);
+      const path = join2(outDir, `${filename}.md`);
+      const vPath = join2(outDir, `${vName}.md`);
+      if (existsSync(path) || existsSync(vPath)) {
+        if (!latest || r.published_at > latest) latest = r.published_at;
+        continue;
+      }
+      writeFileSync2(path, renderGhRelease(target.product, r), "utf-8");
+      fetched++;
+      if (!latest || r.published_at > latest) latest = r.published_at;
+    } catch (e) {
+      errors.push(`${r.tag_name}: ${e.message}`);
+    }
+  }
+  if (latest) writeMarker(db, target.product, latest, target.strategy);
+  return { product: target.product, fetched, newSince: since, latest, errors };
+}
+function ghReleases(repo, sinceIso) {
+  assertRepoShape(repo);
+  const all = [];
+  const MAX_PAGES = 50;
+  for (let page = 1; page <= MAX_PAGES; page++) {
+    let out;
+    try {
+      out = execFileSync(
+        "gh",
+        ["api", `repos/${repo}/releases?per_page=100&page=${page}`],
+        { encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] }
+      );
+    } catch (e) {
+      const stderr = (e.stderr ?? "").toString();
+      if (stderr.includes("404")) return page === 1 ? [] : filterAndShape(all, sinceIso);
+      if (stderr.includes("403") || stderr.includes("429") || stderr.includes("rate limit")) {
+        throw new Error(
+          `GitHub API rate limit hit for ${repo}. Set GITHUB_TOKEN env var for 5000 req/hr (vs 60 unauthenticated). Original error: ${e.message}`
+        );
+      }
+      throw e;
+    }
+    let batch;
+    try {
+      batch = JSON.parse(out);
+    } catch {
+      return page === 1 ? [] : filterAndShape(all, sinceIso);
+    }
+    if (!Array.isArray(batch) || batch.length === 0) break;
+    all.push(...batch);
+    if (batch.length === 100) {
+      const lastPubAt = batch[batch.length - 1]?.published_at;
+      if (lastPubAt && lastPubAt <= sinceIso) break;
+    }
+    if (batch.length < 100) break;
+  }
+  return filterAndShape(all, sinceIso);
+}
+function filterAndShape(all, sinceIso) {
+  return all.filter((r) => r.published_at && r.published_at > sinceIso).map((r) => ({
+    tag_name: r.tag_name,
+    published_at: r.published_at,
+    name: r.name,
+    body: r.body,
+    html_url: r.html_url
+  }));
+}
+function filenameFor(target, tag) {
+  if (target.multiPackage) {
+    return tag.replace(/^@/, "").replace(/\//g, "-").replace(/@/g, "-").replace(/-v(\d)/g, "-$1").replace(/^v/, "");
+  }
+  return tag.replace(/^v/, "");
+}
+function yamlQuote(s) {
+  if (s == null) return "";
+  return s.replace(/[\x00-\x1f]/g, " ").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function renderGhRelease(product, r) {
+  const version = (r.tag_name ?? "").replace(/^v/, "");
+  return [
+    "---",
+    `product: ${product}`,
+    `version: "${yamlQuote(version)}"`,
+    `released_at: "${r.published_at.split("T")[0]}"`,
+    `source_url: "${yamlQuote(r.html_url)}"`,
+    `fetched_at: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+    "---",
+    "",
+    `# ${product} ${r.tag_name}`,
+    "",
+    r.body ?? "(no body)",
+    ""
+  ].join("\n");
+}
+async function fetchRss(db, outDir, target, since, signal) {
+  if (!target.rssUrl) throw new Error(`${target.product}: rss strategy requires rssUrl`);
+  const items = await fetchRssReleases(target.rssUrl, since, target.rssTitleFilter, signal);
+  let latest = null;
+  let fetched = 0;
+  const errors = [];
+  for (const item of items) {
+    try {
+      const safeSlug = sanitizeFilename(item.slug);
+      assertSafeFilename(safeSlug, `rss slug for ${JSON.stringify(item.slug)}`);
+      const path = join2(outDir, `${safeSlug}.md`);
+      if (existsSync(path)) {
+        if (!latest || item.pubDate > latest) latest = item.pubDate;
+        continue;
+      }
+      const body = [
+        "---",
+        `product: ${target.product}`,
+        `version: "${yamlQuote(safeSlug)}"`,
+        `released_at: "${item.pubDate.split("T")[0]}"`,
+        `source_url: "${yamlQuote(item.link)}"`,
+        `fetched_at: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+        `title: "${yamlQuote(item.title ?? "")}"`,
+        "---",
+        "",
+        `# ${target.product} \u2014 ${item.title ?? safeSlug}`,
+        "",
+        item.body ?? "(no body)",
+        ""
+      ].join("\n");
+      writeFileSync2(path, body, "utf-8");
+      fetched++;
+      if (!latest || item.pubDate > latest) latest = item.pubDate;
+    } catch (e) {
+      errors.push(`${item.slug}: ${e.message}`);
+    }
+  }
+  if (latest) writeMarker(db, target.product, latest, target.strategy);
+  return { product: target.product, fetched, newSince: since, latest, errors };
+}
+async function fetchRawChangelog(db, outDir, target, since, signal) {
+  if (!target.rawChangelogUrl) throw new Error(`${target.product}: raw-changelog requires url`);
+  let items;
+  switch (target.rawChangelogParser) {
+    case "aider-history":
+      items = await fetchAiderHistory(target.rawChangelogUrl, since, signal);
+      break;
+    case "keep-a-changelog":
+      items = await fetchKeepAChangelog(target.rawChangelogUrl, since, signal);
+      break;
+    default:
+      throw new Error(`${target.product}: unsupported parser ${target.rawChangelogParser}`);
+  }
+  let latest = null;
+  let fetched = 0;
+  const errors = [];
+  for (const item of items) {
+    try {
+      const safeVersion = sanitizeFilename(item.version);
+      assertSafeFilename(safeVersion, `raw-changelog version for ${JSON.stringify(item.version)}`);
+      const path = join2(outDir, `${safeVersion}.md`);
+      if (existsSync(path)) {
+        if (item.releasedAt && (!latest || item.releasedAt > latest)) latest = item.releasedAt;
+        continue;
+      }
+      const body = [
+        "---",
+        `product: ${target.product}`,
+        `version: "${yamlQuote(safeVersion)}"`,
+        `released_at: ${item.releasedAt ? `"${yamlQuote(item.releasedAt)}"` : "null"}`,
+        `source_url: "${yamlQuote(target.rawChangelogUrl ?? "")}"`,
+        `fetched_at: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+        "---",
+        "",
+        `# ${target.product} v${item.version}`,
+        "",
+        item.body,
+        ""
+      ].join("\n");
+      writeFileSync2(path, body, "utf-8");
+      fetched++;
+      if (item.releasedAt && (!latest || item.releasedAt > latest)) latest = item.releasedAt;
+    } catch (e) {
+      errors.push(`${item.version}: ${e.message}`);
+    }
+  }
+  if (latest) writeMarker(db, target.product, latest, target.strategy);
+  return { product: target.product, fetched, newSince: since, latest, errors };
+}
+async function fetchHtmlScrape(db, outDir, target, since, signal) {
+  if (!target.htmlParser) throw new Error(`${target.product}: html-scrape requires htmlParser`);
+  const items = await fetchHtmlReleases(target.htmlParser, since, signal);
+  let latest = null;
+  let fetched = 0;
+  const errors = [];
+  for (const item of items) {
+    try {
+      const safeSlug = sanitizeFilename(item.slug);
+      assertSafeFilename(safeSlug, `html-scrape slug for ${JSON.stringify(item.slug)}`);
+      const path = join2(outDir, `${safeSlug}.md`);
+      if (existsSync(path)) {
+        if (!latest || item.pubDate > latest) latest = item.pubDate;
+        continue;
+      }
+      const body = [
+        "---",
+        `product: ${target.product}`,
+        `version: "${yamlQuote(safeSlug)}"`,
+        `released_at: "${item.pubDate.split("T")[0]}"`,
+        `source_url: "${yamlQuote(item.link)}"`,
+        `fetched_at: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+        `title: "${yamlQuote(item.title ?? "")}"`,
+        "---",
+        "",
+        `# ${target.product} \u2014 ${item.title ?? safeSlug}`,
+        "",
+        item.body ?? "(no body)",
+        ""
+      ].join("\n");
+      writeFileSync2(path, body, "utf-8");
+      fetched++;
+      if (!latest || item.pubDate > latest) latest = item.pubDate;
+    } catch (e) {
+      errors.push(`${item.slug}: ${e.message}`);
+    }
+  }
+  if (latest) writeMarker(db, target.product, latest, target.strategy);
+  return { product: target.product, fetched, newSince: since, latest, errors };
+}
+async function fetchPlaywrightStrategy(db, outDir, target, since) {
+  const { fetchWindsurfWithPlaywright } = await import("./fetch-playwright-HQ6OTMSQ.js");
+  const items = await fetchWindsurfWithPlaywright(since);
+  let latest = null;
+  let fetched = 0;
+  const errors = [];
+  for (const item of items) {
+    try {
+      const safeSlug = sanitizeFilename(item.slug);
+      assertSafeFilename(safeSlug, `playwright slug for ${JSON.stringify(item.slug)}`);
+      const path = join2(outDir, `${safeSlug}.md`);
+      if (existsSync(path)) {
+        if (!latest || item.pubDate > latest) latest = item.pubDate;
+        continue;
+      }
+      const body = [
+        "---",
+        `product: ${target.product}`,
+        `version: "${yamlQuote(safeSlug)}"`,
+        `released_at: "${item.pubDate.split("T")[0]}"`,
+        `source_url: "${yamlQuote(item.link)}"`,
+        `fetched_at: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"`,
+        `title: "${yamlQuote(item.title ?? "")}"`,
+        "---",
+        "",
+        `# ${target.product} \u2014 ${item.title ?? safeSlug}`,
+        "",
+        item.body ?? "(no body)",
+        ""
+      ].join("\n");
+      writeFileSync2(path, body, "utf-8");
+      fetched++;
+      if (!latest || item.pubDate > latest) latest = item.pubDate;
+    } catch (e) {
+      errors.push(`${item.slug}: ${e.message}`);
+    }
+  }
+  if (latest) writeMarker(db, target.product, latest, target.strategy);
+  return { product: target.product, fetched, newSince: since, latest, errors };
+}
+async function fetchCatalogStrategy(db, productsRoot, target, since, signal) {
+  if (!target.catalogType) throw new Error(`${target.product}: catalog requires catalogType`);
+  const entries = await fetchCatalog(target.catalogType, { maxEntries: target.catalogMaxEntries, signal });
+  const productDir = resolve(productsRoot, target.product);
+  writeCatalog(productDir, target.product, entries);
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  writeMarker(db, target.product, nowIso, target.strategy);
+  return {
+    product: target.product,
+    fetched: entries.length,
+    newSince: since,
+    latest: nowIso,
+    errors: []
+  };
+}
+function readMarker(db, product) {
+  const row = db.prepare(`SELECT version FROM markers WHERE product = ? AND name = 'last_fetched_release_at'`).get(product);
+  return row?.version ?? null;
+}
+function writeMarker(db, product, isoTimestamp, fetchStrategy = "gh-releases") {
+  assertProductShape(product);
+  db.prepare(`
+    INSERT OR IGNORE INTO products (name, display_name, source_tier, source_url, fetch_strategy, notes)
+    VALUES (?, ?, 1, '', ?, NULL)
+  `).run(product, product, fetchStrategy);
+  db.prepare(`
+    INSERT INTO markers (product, name, version, updated_at)
+    VALUES (?, 'last_fetched_release_at', ?, ?)
+    ON CONFLICT(product, name) DO UPDATE SET version = excluded.version, updated_at = excluded.updated_at
+  `).run(product, isoTimestamp, (/* @__PURE__ */ new Date()).toISOString());
+}
+function listFetchTargets() {
+  return TARGETS;
+}
+function seedMarkersFromDb(db) {
+  const rows = db.prepare(
+    `SELECT product, MAX(released_at) AS max_date FROM releases WHERE released_at IS NOT NULL GROUP BY product`
+  ).all();
+  const out = [];
+  for (const t of TARGETS) {
+    const r = rows.find((x) => x.product === t.product);
+    if (r?.max_date) {
+      const iso = r.max_date.includes("T") ? r.max_date : `${r.max_date}T23:59:59Z`;
+      writeMarker(db, t.product, iso, t.strategy);
+      out.push({ product: t.product, seededTo: iso });
+    } else {
+      out.push({ product: t.product, seededTo: null });
+    }
+  }
+  return out;
+}
+
+export {
+  fetchAll,
+  listFetchTargets,
+  seedMarkersFromDb
+};