30/7/26

see feedgate_readme.txt for licence, setup instructions, and terms of use.

// =====================================================================
// FEEDGATE v7.8 - Personal RSS Aggregator & Webhook Engine
// =====================================================================


// =====================================================================
// PART 1: CLOUDFLARE WORKER
// Save as worker.js and deploy via the Cloudflare Workers dashboard.
//
// Bindings required (set in the Worker's Settings > Variables):
//   FEEDGATE_KV    -- KV Namespace binding
//   WEBHOOK_SECRET -- Secret (authenticates incoming webhook posts)
// =====================================================================


// ═══════════════════════════════════════════════════════════════════════════
// FEEDGATE WORKER v7.8
// ═══════════════════════════════════════════════════════════════════════════
// Changes in v7.8:
// fixed new feed old item cap, webhook budget, increasted lock ttl
// Changes in v7.6:
//   - scheduled() rewritten to process gates in a controllable order
//     (cron_order in KV), chunked to stay under the free-tier subrequest
//     cap, with a KV lock to prevent overlapping runs.
// Changes in v7.5
// Adding a feed to an existing gate now adds only one old item.
// Items from feeds with no <title> on items will then show the channel name instead.
// Changes in v7.4:
//   - checkRule() replaced \b regex word boundary logic with a manual loop-based
//     word-boundary check using indexOf and character inspections.
//   - buildRss() wraps dateObj.toUTCString() in try/catch with fallback.
// RETAINED FEATURES:
//   - Restored try/catch around dateObj.toISOString() in the items:slug JSON
//     export.
//   - Image extraction now checks the type= attribute on media:content /
//     media:thumbnail / enclosure tags and rejects obviously non-image URLs
//     (video/audio extensions, YouTube/Vimeo/Dailymotion links) before
//     falling through to <img> tags in description/content.
//   - imageUrl extraction and propagation to RSS <media:content> output and
//     the items:slug JSON export.
//   - Webhook ingest logic and master weighting.
// ═══════════════════════════════════════════════════════════════════════════

const FETCH_TIMEOUT_MS = 3000;
const MAX_WEBHOOK_ITEMS = 100;
const MAX_SEEN_ITEMS = 300;
const UA_SPOOF = 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1';

export default {
  async fetch(request, env, ctx) {
    if (request.method === "OPTIONS") {
      return new Response(null, {
        headers: {
          "Access-Control-Allow-Origin": "*",
          "Access-Control-Allow-Methods": "GET, HEAD, POST, PUT, OPTIONS",
          "Access-Control-Allow-Headers": "Cache-Control, Pragma, Content-Type",
          "Access-Control-Max-Age": "86400",
        },
      });
    }

    const url = new URL(request.url);
    const path = url.pathname.substring(1);

    if (!path || path === "") {
return new Response("FeedGate v7.8 Active.", { status: 200 });
    }

    if (request.method === "POST" || request.method === "PUT") {
      return handleWebhook(request, env, path);
    }

    const raw = await env.FEEDGATE_KV.get("gate:" + path);
    if (!raw) return new Response("Gate Not Found: " + path, { status: 404 });
    const gate = JSON.parse(raw);

    const isHardRefresh = request.headers.get("Cache-Control") === "no-cache" || request.headers.get("Pragma") === "no-cache";

return processGate(request, env, ctx, gate, isHardRefresh);
  },

async scheduled(event, env, ctx) {
const LOCK_TTL_SECONDS = 180;
    const SUBREQUEST_BUDGET = 45;

    const lockRaw = await env.FEEDGATE_KV.get("cron_lock");
    if (lockRaw) return; // a previous run is still in progress

    await env.FEEDGATE_KV.put("cron_lock", "1", { expirationTtl: LOCK_TTL_SECONDS });

    try {
      const list = await env.FEEDGATE_KV.list({ prefix: "gate:" });
      const realSlugs = new Set(list.keys.map(k => k.name.substring(5)));
      if (realSlugs.size === 0) return;

      const orderRaw = await env.FEEDGATE_KV.get("cron_order");
      let order = orderRaw ? JSON.parse(orderRaw) : [];

      order = order.filter(slug => realSlugs.has(slug));
      for (const slug of realSlugs) {
        if (!order.includes(slug)) order.push(slug);
      }
      await env.FEEDGATE_KV.put("cron_order", JSON.stringify(order));

      const n = order.length;
      let cursorRaw = await env.FEEDGATE_KV.get("cron_cursor");
      let i = cursorRaw ? (parseInt(cursorRaw) % n) : 0;

      const toProcess = [];
      let subrequestTotal = 0;

      for (let visited = 0; visited < n; visited++) {
        const slug = order[i];
        const gateRaw = await env.FEEDGATE_KV.get("gate:" + slug);
        const gate = gateRaw ? JSON.parse(gateRaw) : null;
const sourceCount = gate ? (gate.sources || []).filter(s => s.url && s.url.startsWith('http')).length : 0;
        const webhookCost = gate ? (gate.outputWebhooks?.length || 0) * 3 : 0;
        const gateCost = sourceCount + webhookCost;

        if (toProcess.length > 0 && subrequestTotal + gateCost > SUBREQUEST_BUDGET) break;

        toProcess.push(slug);
        subrequestTotal += gateCost;
        i = (i + 1) % n;
      }

      for (const slug of toProcess) {
        await processSlugOutput(slug, env, ctx);
      }

      await env.FEEDGATE_KV.put("cron_cursor", String(i));
    } finally {
      await env.FEEDGATE_KV.delete("cron_lock");
    }
  }
};

async function processSlugOutput(slug, env, ctx) {
    const raw = await env.FEEDGATE_KV.get("gate:" + slug);
    if (!raw) return;
    const gate = JSON.parse(raw);
    if (!gate.outputWebhooks || gate.outputWebhooks.length === 0) return;

    const fakeRequest = new Request("https://internal/" + slug);
    await processGate(fakeRequest, env, ctx, gate, false);
    const items = await env.FEEDGATE_KV.get("items:" + slug);
    if (!items) return;
    const itemsJson = JSON.parse(items);

    const seenKey = "webhook_seen:" + slug;
    const seenRaw = await env.FEEDGATE_KV.get(seenKey);
    const isFirstRun = !seenRaw;
    let seen = seenRaw ? JSON.parse(seenRaw) : [];
    const seenSet = new Set(seen);

    const makeGuid = (it) => it.link || (it.title + "|" + (it.description || "").slice(0, 100));

    const newItems = itemsJson.items.filter(it => !seenSet.has(makeGuid(it)));

    for (const it of itemsJson.items) {
      const guid = makeGuid(it);
      if (!seenSet.has(guid)) { seen.push(guid); seenSet.add(guid); }
    }
    seen = seen.slice(-MAX_SEEN_ITEMS);
    await env.FEEDGATE_KV.put(seenKey, JSON.stringify(seen));

    if (isFirstRun) return;

    for (const it of newItems) {
      const payload = {
        title: it.title || "",
        link: it.link || "",
        text: it.description || it.content || "",
        source: gate?.proxy?.title || slug,
        imageUrl: it.imageUrl || ""
      };
      for (const wh of gate.outputWebhooks) {
        if (!wh.url) continue;
        const whUrl = wh.url + (wh.secret ? (wh.url.includes('?') ? '&' : '?') + `secret=${encodeURIComponent(wh.secret)}` : "");
try {
          const isFeedPost = env.FEEDPOST && whUrl.includes("feedpost");
          const whRes = isFeedPost
            ? await env.FEEDPOST.fetch(new Request(whUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) }))
            : await fetch(whUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) });
          const whBodyText = await whRes.text();
          console.log(`Webhook push to ${wh.name || whUrl}: HTTP ${whRes.status} — Body: ${whBodyText.slice(0, 300)}`);
        } catch(e) {
          console.log(`Webhook push FAILED to ${wh.name || whUrl}: ${e.message}`);
        }
      }
    }
}

// ── Webhook Handler ─────────────────────────────────────────────────────────

async function handleWebhook(request, env, gateId) {
  const url = new URL(request.url);
  const secret = url.searchParams.get("secret");
  if (!env.WEBHOOK_SECRET || secret !== env.WEBHOOK_SECRET) {
    return new Response("Unauthorised", { status: 401 });
  }

  const gateRaw = await env.FEEDGATE_KV.get("gate:" + gateId);
  if (!gateRaw) return new Response("Gate Not Found", { status: 404 });

  let payload;
  try { payload = await request.json(); }
  catch(e) { return new Response("Invalid JSON", { status: 400 }); }

  const now = Date.now();
  const bodyText = payload.text || payload.summary || payload.description || "";

  const item = {
    title:       (payload.title || bodyText.slice(0, 80) || "New item").trim(),
    description: bodyText,
    content:     bodyText,
    imageUrl:    payload.imageUrl || "",
    link:        payload.link     || payload.url || "",
    pubDate:     new Date(now).toUTCString(),
    sourceTitle: payload.source   || "Webhook",
    isWebhook:   true
  };

  const indexKey = "webhook_index:" + gateId;
  const itemKey  = "webhook_item:" + gateId + ":" + now;

  const rawIndex = await env.FEEDGATE_KV.get(indexKey);
  let index = rawIndex ? JSON.parse(rawIndex) : [];
  index.unshift(itemKey);
  const trimmed = index.slice(0, MAX_WEBHOOK_ITEMS);

  await env.FEEDGATE_KV.put(itemKey, JSON.stringify(item));
  await env.FEEDGATE_KV.put(indexKey, JSON.stringify(trimmed));

  return new Response("OK", { status: 200 });
}

// ── Gate Processing Logic ───────────────────────────────────────────────────

async function processGate(request, env, ctx, gate, refresh) {
  try {
    const gateId = new URL(request.url).pathname.substring(1);

    const rssSources = (gate.sources || []).filter(s => s.url.startsWith('http'));
    const webhookConfigs = (gate.sources || []).filter(s => !s.url.startsWith('http'));

    const rssResults = await Promise.allSettled(rssSources.map(s => fetchSource(s.url, request, env, refresh)));
    let feedData = rssResults.map((res, i) => ({
      items: res.status === 'fulfilled' ? parseItems(res.value, rssSources[i].url) : [],
      weight: parseInt(rssSources[i].weight) || 1,
      url: rssSources[i].url
    }));

// First-seen cap: limit new RSS sources to 1 item on their first appearance
const seenSourcesKey = "source_first_seen:" + gateId;
    const seenSourcesRaw = await env.FEEDGATE_KV.get(seenSourcesKey);
    const isFirstSourceRun = !seenSourcesRaw;
    const seenSources = new Set(seenSourcesRaw ? JSON.parse(seenSourcesRaw) : []);
    let seenSourcesChanged = false;
    for (const f of feedData) {
      if (!seenSources.has(f.url)) {
        if (!isFirstSourceRun) f.items = f.items.slice(0, 1);
        seenSources.add(f.url);
        seenSourcesChanged = true;
      }
    }
    if (seenSourcesChanged) {
      await env.FEEDGATE_KV.put(seenSourcesKey, JSON.stringify([...seenSources]));
    }

    const webhookRawIndex = await env.FEEDGATE_KV.get("webhook_index:" + gateId);
    if (webhookRawIndex) {
      const webhookIndex = JSON.parse(webhookRawIndex);
      const webhookItemsRaw = await Promise.all(webhookIndex.map(k => env.FEEDGATE_KV.get(k)));
      const webhookItems = webhookItemsRaw.filter(Boolean).map(v => {
        const it = JSON.parse(v);
        it.dateObj = new Date(it.pubDate);
        return it;
      });

      const groups = webhookItems.reduce((acc, it) => {
        const name = it.sourceTitle;
        if (!acc[name]) {
          const config = webhookConfigs.find(c => c.url.toLowerCase() === name.toLowerCase());
          acc[name] = {
            items: [],
            weight: config ? parseInt(config.weight) : 1,
            url: "webhook:" + name
          };
        }
        acc[name].items.push(it);
        return acc;
      }, {});

      Object.values(groups).forEach(group => feedData.push(group));
    }

    let ageLimit = parseInt(gate?.ageLimit);
    if (isNaN(ageLimit)) {
      ageLimit = parseInt(gate?.proxy?.ageLimit) || 0;
    }

    if (ageLimit && ageLimit > 0) {
      const cutoff = Date.now() - (ageLimit * 24 * 60 * 60 * 1000);
      feedData.forEach(f => { f.items = f.items.filter(it => it.dateObj.getTime() > cutoff); });
    }

    feedData.forEach(f => {
      f.items = f.items.filter(item => {
        let incPass = true;
        if (gate.rulesInclude?.length) {
          incPass = checkRule(item, gate.rulesInclude[0]);
          for (let i = 1; i < gate.rulesInclude.length; i++) {
            const m = checkRule(item, gate.rulesInclude[i]);
            if (gate.rulesInclude[i].logic === 'Or') incPass = incPass || m;
            else incPass = incPass && m;
          }
        }
        let excFail = false;
        if (gate.rulesExclude?.length) {
          excFail = checkRule(item, gate.rulesExclude[0]);
          for (let i = 1; i < gate.rulesExclude.length; i++) {
            const m = checkRule(item, gate.rulesExclude[i]);
            if (gate.rulesExclude[i].logic === 'Or') excFail = excFail || m;
            else excFail = excFail && m;
          }
        }
        return incPass && !excFail;
      });
    });

    let totalSlots = parseInt(gate?.maxItems);
    if (isNaN(totalSlots)) {
      totalSlots = parseInt(gate?.proxy?.maxItems) || 20;
    }
    totalSlots = totalSlots || 20;

    let finalItems = [];
    let scores = feedData.map(() => 0);
    const totalWeight = feedData.reduce((sum, f) => sum + f.weight, 0);

    for (let s = 0; s < totalSlots; s++) {
      let bestIdx = -1;
      for (let i = 0; i < feedData.length; i++) {
        if (feedData[i].items.length > 0) {
          scores[i] += feedData[i].weight;
          if (bestIdx === -1 || scores[i] > scores[bestIdx]) bestIdx = i;
        }
      }
      if (bestIdx === -1) break;
      finalItems.push(feedData[bestIdx].items.shift());
      if (totalWeight > 0) scores[bestIdx] -= totalWeight;
    }

    finalItems.sort((a, b) => b.dateObj - a.dateObj);

    if (gateId) {
      try {
        const itemsJson = {
          slug: gateId,
          generatedAt: new Date().toISOString(),
          title: gate?.proxy?.title || gate?.widget?.title || gateId,
          items: finalItems.map(it => {
            let pubDateIso;
            try { pubDateIso = it.dateObj.toISOString(); }
            catch(e) { pubDateIso = new Date().toISOString(); }
            return {
              title: it.title,
              link: it.link,
              pubDate: pubDateIso,
              description: it.description,
              content: it.content,
              author: it.author || "",
              sourceTitle: it.sourceTitle,
              sourceUrl: it.sourceUrl || it.link,
              imageUrl: it.imageUrl || ""
            };
          })
        };
        await env.FEEDGATE_KV.put("items:" + gateId, JSON.stringify(itemsJson), { expirationTtl: 86400 });
      } catch(e) {}
    }

    const body = buildRss(gate?.proxy?.title || "FeedGate", finalItems, request.url);
    return serveResponse(body);
  } catch(e) { return new Response("Error: " + e.message, { status: 500 }); }
}

// ── Helpers ──────────────────────────────────────────────────────────────────

function serveResponse(body) {
  return new Response(body, {
    headers: {
      "Access-Control-Allow-Origin": "*",
      "Cache-Control": "public, max-age=60",
      "Access-Control-Allow-Headers": "Cache-Control, Pragma",
      "Content-Type": "application/rss+xml;charset=UTF-8"
    }
  });
}

function extractRootDomain(url) {
  try {
    const hostname = new URL(url).hostname.toLowerCase();
    const parts = hostname.split('.').filter(p => p !== 'www');
    if (parts.length <= 2) return parts.join('.');
    const isTwoPartTld = parts[parts.length - 2].length <= 3;
    return isTwoPartTld ? parts.slice(-3).join('.') : parts.slice(-2).join('.');
  } catch(e) { return "News Source"; }
}

function decodeEntities(s) {
  if (!s) return "";
  return s.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(n))
          .replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCharCode(parseInt(n, 16)))
          .replace(/&quot;/g, '"').replace(/&amp;/g, '&').replace(/&lt;/g, '<')
          .replace(/&gt;/g, '>').replace(/&apos;/g, "'").replace(/&nbsp;/g, ' ');
}

async function fetchSource(urlStr, request, env, refresh) {
  const target = new URL(urlStr.includes('freshrss') ? urlStr.replace('a=normal','a=rss') : urlStr);
  const worker = new URL(request.url);
  if (target.host === worker.host) {
    const raw = await env.FEEDGATE_KV.get("gate:" + target.pathname.substring(1));
    if (raw) return (await processGate(request, env, {waitUntil:()=>{}}, JSON.parse(raw), refresh)).text();
  }
  const res = await fetch(urlStr, { headers: {'User-Agent': UA_SPOOF}, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
  if (!res.ok) throw new Error("HTTP " + res.status + " on " + urlStr);
  return res.text();
}

function checkRule(item, rule) {
  const map = {
    title: item.title,
    text: (item.title + " " + item.description + " " + item.content),
    author: item.author,
    url: item.sourceUrl || item.link
  };
  const key = (rule.key || "").trim();
  let pattern = key.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
  if (!pattern) return true;

  const text = map[rule.target] || "";
  const rx = new RegExp(pattern, "i");
  if (!rx.test(text)) return false;

  // Manual word-boundary check for title/text targets
  if (rule.target === 'title' || rule.target === 'text') {
    const lowerText = text.toLowerCase();
    const lowerKey = key.toLowerCase();
    let pos = lowerText.indexOf(lowerKey);
    while (pos !== -1) {
      const before = pos > 0 ? text.charAt(pos - 1) : "";
      const after = pos + key.length < text.length ? text.charAt(pos + key.length) : "";
      if (!/\w/.test(before) && !/\w/.test(after)) return true;
      pos = lowerText.indexOf(lowerKey, pos + 1);
    }
    return false;
  }
  return true;
}

function parseItems(xml, sourceUrl) {
  const matches = [...xml.matchAll(/<(item|entry)>([\s\S]*?)<\/(item|entry)>/gi)];
  const feedTitle = (xml.match(/<title[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/title>/i) || [])[1]?.replace(/<[^>]*>/g,"").trim() || "Source";
  return matches.map(m => {
    const b = m[2];
const rawT = (b.match(/<title[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/title>/i) || [])[1] || feedTitle;
    let l = (b.match(/<link>([^<]+)<\/link>/i) || b.match(/<link[^>]+href="([^"]+)"/i) || [])[1]?.trim() || "#";
    try { l = new URL(l, sourceUrl).href; } catch(e){}
    const d = b.match(/<(pubDate|updated|published)>(.*?)<\/(pubDate|updated|published)>/i);
    const rawDesc = (b.match(/<(description|summary)[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/(description|summary)>/i) || [])[2] || "";
    const rawCont = (b.match(/<content:encoded>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/content:encoded>/i) || b.match(/<content[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/content>/i) || [])[1] || "";

    let img = "";
    const mediaRe = /<(?:media:content|media:thumbnail|enclosure)([^>]*)>/gi;
    let mm;
    while ((mm = mediaRe.exec(b)) !== null) {
      const attrs = mm[1];
      const urlMatch = attrs.match(/url=["']([^"']+)["']/i);
      if (!urlMatch) continue;
      const candidate = urlMatch[1];
      const typeMatch = attrs.match(/type=["']([^"']+)["']/i);
      if (typeMatch && !typeMatch[1].toLowerCase().startsWith("image")) continue;
      if (/\.(mp4|m4v|mov|webm|m3u8|avi|mkv|flv|mp3|m4a|wav|ogg)(?:\?.*)?$/i.test(candidate)) continue;
      if (/(?:youtube\.com|youtu\.be|vimeo\.com|dailymotion\.com)/i.test(candidate)) continue;
      img = candidate;
      break;
    }
    if (!img) {
      const inDesc = rawDesc.match(/<img[^>]+src=["']([^"']+)["']/i) || rawCont.match(/<img[^>]+src=["']([^"']+)["']/i);
      if (inDesc) img = inDesc[1];
    }

    let authMatch = b.match(/<(dc:creator|author)[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/(dc:creator|author)>/i);
    let author = "";
    if (authMatch && authMatch[2]) {
      author = decodeEntities(authMatch[2].replace(/<[^>]*>/g,"").trim());
      if (author.toLowerCase().includes("author") || author.toLowerCase().includes("dc:creator")) author = "";
    }
    const isrc = b.match(/<source[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/source>/i);
    let resolvedSource = decodeEntities(isrc ? isrc[1] : feedTitle).trim();
    const lowerSource = resolvedSource.toLowerCase();
    if (!resolvedSource || lowerSource === "source" || lowerSource === "unknown source") {
      resolvedSource = extractRootDomain(sourceUrl);
    }
    return {
      title: decodeEntities(rawT.replace(/<[^>]*>/g,"")),
      link: l,
      pubDate: d ? d[2] : "",
      dateObj: d ? new Date(d[2]) : new Date(),
      description: decodeEntities(rawDesc),
      content: decodeEntities(rawCont),
      imageUrl: img,
      author: author,
      sourceTitle: resolvedSource,
      sourceUrl: sourceUrl
    };
  });
}

function esc(s) { return String(s||"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;"); }

function buildRss(title, items, url) {
  const itemXml = items.map(it => {
    const safeDesc = it.description.replace(/<!\[CDATA\[/gi, "").replace(/\]\]>/gi, "");
    const mediaTag = it.imageUrl ? `<media:content url="${esc(it.imageUrl)}" medium="image"/>` : "";
    let pubDateStr;
    try { pubDateStr = it.dateObj.toUTCString(); } catch(e) { pubDateStr = new Date().toUTCString(); }
    return `<item><title>${esc(it.title)}</title><link>${esc(it.link)}</link><pubDate>${pubDateStr}</pubDate><guid isPermaLink="false">${esc(it.link + it.title)}</guid><description><![CDATA[${safeDesc}]]></description><source url="${esc(it.sourceUrl || it.link)}">${esc(it.sourceTitle)}</source>${mediaTag}</item>`;
  }).join("");
  return `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>${esc(title)}</title><link>${esc(url)}</link><description>FeedGate v7.8 Merged Feed</description>${itemXml}</channel></rss>`;
}


// =====================================================================
// PART 2: PAGES FUNCTIONS (Admin API)
//
// Before uploading to GitHub, you need to create these files on your
// computer. Create a folder called "functions", then create the
// subfolders and files inside it exactly as shown below. The folder
// names and file names must be copied exactly -- Cloudflare Pages
// uses them to set up your API routes automatically.
//
// Your folder structure should look like this:
//   index.html
//   functions/
//     _middleware.js
//     api/
//       config.js
//       cron-order.js
//       feeds/
//         [[path]].js
//
// Once created, upload the index.html file AND the entire functions/
// folder to your GitHub repository (step 6 of the setup guide).
//
// Bindings required on the Pages project (Settings > Functions):
//   FEEDGATE_KV   -- KV Namespace binding (same namespace as the Worker)
//   ADMIN_SECRET  -- Secret (your admin UI login password)
//   WORKER_URL    -- Environment Variable (your Worker's full URL)
// =====================================================================

// ---------------------------------------------------------------------
// FILE: functions/_middleware.js
// Runs on every /api/ request. Checks the admin password header,
// except /api/config which is public (needed to load the UI).
// ---------------------------------------------------------------------

export async function onRequest(context) {
  const { request, env } = context;
  const url = new URL(request.url);
  if (!url.pathname.startsWith("/api/") || url.pathname === "/api/config") {
    return context.next();
  }
  const secret = request.headers.get("X-FeedGate-Secret");
  if (secret !== env.ADMIN_SECRET) {
    return new Response("Unauthorized", { status: 401 });
  }
  return context.next();
}


// ---------------------------------------------------------------------
// FILE: functions/api/config.js
// Returns the Worker URL to the Admin UI so it can build feed links.
// ---------------------------------------------------------------------

export async function onRequest(context) {
  return new Response(JSON.stringify({
    workerUrl: context.env.WORKER_URL || ""
  }), {
    headers: { "Content-Type": "application/json" }
  });
}


// ---------------------------------------------------------------------
// FILE: functions/api/feeds/[[path]].js
// Handles all gate CRUD operations:
//   GET    /api/feeds        -- list all gates
//   GET    /api/feeds/:slug  -- get one gate
//   POST   /api/feeds        -- create gate
//   PUT    /api/feeds/:slug  -- update gate
//   DELETE /api/feeds/:slug  -- delete gate
// ---------------------------------------------------------------------

export async function onRequest(context) {
  const { request, env } = context;
  const url = new URL(request.url);

  const segments = url.pathname.split('/').filter(Boolean);
  const slug = segments.length > 2 ? segments[2] : null;

  if (request.method === "GET") {
    if (slug) {
      const data = await env.FEEDGATE_KV.get("gate:" + slug);
      if (!data) return new Response("Not Found", { status: 404 });
      return new Response(data, { headers: { "Content-Type": "application/json" } });
    }
    const list = await env.FEEDGATE_KV.list({ prefix: "gate:" });
    const feeds = [];
    for (const k of list.keys) {
      const val = await env.FEEDGATE_KV.get(k.name);
      try {
        const parsed = JSON.parse(val);
        feeds.push({
          slug: k.name.replace("gate:", ""),
          title: parsed.proxy?.title || "Untitled",
          primarySource: parsed.sources?.[0]?.url || "None"
        });
      } catch (e) { continue; }
    }
    return new Response(JSON.stringify(feeds), { headers: { "Content-Type": "application/json" } });
  }

  if (request.method === "POST" || request.method === "PUT") {
    const body = await request.json();
    const targetSlug = body.slug;
    if (!targetSlug) return new Response("Slug Required", { status: 400 });
    if (request.method === "POST") {
      const exists = await env.FEEDGATE_KV.get("gate:" + targetSlug);
      if (exists) return new Response("Conflict", { status: 409 });
    }
    await env.FEEDGATE_KV.put("gate:" + targetSlug, JSON.stringify(body.gate));
    return new Response("OK");
  }

  if (request.method === "DELETE" && slug) {
    await env.FEEDGATE_KV.delete("gate:" + slug);
    return new Response("Deleted");
  }

  return new Response("Method Not Allowed", { status: 405 });
}


// ---------------------------------------------------------------------
// FILE: functions/api/cron-order.js
// GET: returns the saved gate processing order.
// PUT: saves a new order (array of slug strings).
// ---------------------------------------------------------------------

export async function onRequest(context) {
  const { request, env } = context;
  if (request.method === "GET") {
    const raw = await env.FEEDGATE_KV.get("cron_order");
    const order = raw ? JSON.parse(raw) : [];
    return new Response(JSON.stringify({ order }), { headers: { "Content-Type": "application/json" } });
  }
  if (request.method === "PUT") {
    const body = await request.json();
    const order = Array.isArray(body.order) ? body.order.filter(s => typeof s === "string") : [];
    await env.FEEDGATE_KV.put("cron_order", JSON.stringify(order));
    return new Response("OK");
  }
  return new Response("Method Not Allowed", { status: 405 });
}





// =====================================================================
// PART 3: ADMIN UI
// Save as index.html in the root of your GitHub repository.
// =====================================================================

<!DOCTYPE html>
<!-- FeedGate Admin UI v3.3 -->
<html lang="en">
<head>
<meta charset="UTF-8"><title>FeedGate 3.3</title>
<style>
  body { background: white; color: black; font-family: Verdana, sans-serif; max-width: 700px; margin: 40px auto; padding: 0 20px; }
  h1 { font-size: 1.2em; }
  h2 {
    font-size: 1em; margin-top: 32px; padding: 8px 10px; background: #f0f0f0;
    cursor: pointer; user-select: none;
    display: flex; align-items: center; justify-content: space-between;
  }
  .section-body { display: none; }
  label { display: block; margin-top: 16px; font-size: 0.9em; font-weight: bold; }
  input, select, textarea { width: 100%; padding: 6px; margin-top: 4px; box-sizing: border-box; font-family: Verdana; border: 1px solid #ccc; font-size: 0.9em; }
  .required { color: red; margin-left: 4px; }
  .short { width: 120px !important; }
  .row { display: flex; gap: 4px; align-items: center; margin-top: 8px; }
  button { padding: 8px 14px; cursor: pointer; border: 1px solid #ccc; background: #eee; font-family: Verdana; border-radius: 0; }
  .btn-small { padding: 4px 8px; font-size: 0.8em; }
  .feed-item { border-bottom: 1px solid #eee; padding: 12px 0; cursor: pointer; }
  .feed-details { display: none; background: #fdfdfd; padding: 15px; margin-top: 10px; border: 1px solid #eee; }
  .slug-line { font-weight: bold; color: #333; }
  .src-line { font-size: 0.8em; color: #666; }
  code { background: #f0f0f0; padding: 0.2em 0.4em; border-radius: 3px; word-break: break-all; font-family: monospace; }
  pre { background: #f0f0f0; padding: 1em; overflow-x: auto; white-space: pre-wrap; word-break: break-all; border-radius: 4px; font-size: 0.85em; margin-top: 8px; }
  #loginOverlay { position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: white; z-index: 100; display: flex; align-items: center; justify-content: center; }
</style>
</head>
<body>

<div id="loginOverlay" style="display:none">
  <div style="width: 300px">
    <h1>FeedGate Login</h1>
    <label>Admin Secret</label>
<input type="password" id="adminSecret" onkeydown="if(event.key==='Enter')doLogin()">
    <button onclick="doLogin()" style="margin-top:20px; width:100%">Login</button>
  </div>
</div>

<div id="dashboard">
<h1>FeedGate 3.3</h1>
  <button onclick="showEditor()">+ Create New Gate</button>

  <h2 onclick="toggleSection(this)"><span>Cron Processing Order</span></h2>
  <div class="section-body">
    <p style="font-size:0.85em; color:#444;">Controls which gates the scheduled cron run processes first. When the subrequest budget runs out mid-cycle, gates further down this list wait for the next run.</p>
    <div id="cronOrderList" style="margin-top:8px">Loading order...</div>
    <button onclick="saveCronOrder()" style="margin-top:12px">Save Order</button>
  </div>

  <div id="feedList" style="margin-top:20px">Loading feeds...</div>
</div>

<div id="editor" style="display:none">
  <h1 id="editorTitle">New Gate</h1>
  <button onclick="showDashboard()">← Back to Dashboard</button>

  <label>Slug (URL path) <span class="required">*</span></label>
  <input type="text" id="slug" placeholder="my-feed" oninput="updateWebhookInfo()">

  <!-- WEBHOOK SETUP -->
<h2 onclick="toggleSection(this)"><span>← Incoming Webhook Setup</span></h2>
  <div class="section-body">
    <p style="font-size:0.85em; color:#444;">Push items directly to this gate using a JSON webhook.</p>

<label>← Incoming Endpoint URL</label>
    <div style="background:#f0f0f0; padding:10px; display:flex; align-items:center; gap:10px; margin-top:4px;">
      <code id="webhookUrl" style="flex-grow:1;">[Enter slug first]</code>
      <button class="btn-small" onclick="copyWebhookUrl(this)">Copy</button>
    </div>
    <p style="font-size:0.8em; color:#666; margin-top:4px;">Replace <code>YOUR_SECRET</code> with your <code>WEBHOOK_SECRET</code>.</p>

    <label>JSON Payload Schema</label>
    <pre id="webhookPayload">{
  "title": "Item Title",
  "link": "https://example.com",
  "text": "Item description or content...",
  "source": "My App Name",
  "imageUrl": ""
}</pre>
    <button class="btn-small" style="margin-top:8px" onclick="copyPayload(this)">Copy Sample Payload</button>
  </div>

  <!-- GENERAL SETTINGS -->
  <h2 onclick="toggleSection(this)"><span>General Settings</span></h2>
<div class="section-body">
    <label>Feed Title</label><input type="text" id="pTitle" placeholder="e.g. West Ham News">
    <label>Age Limit (Days)</label><input type="number" id="pAge" value="30" class="short">
    <label>Max Items</label><input type="number" id="pMax" value="20" class="short">
  </div>

  <!-- SOURCES -->
    <h2 onclick="toggleSection(this)"><span>Sources</span></h2>
  <div class="section-body">
<div style="font-size:0.85em; color:#444; margin-bottom:12px;">Enter an RSS URL, or a plain name (e.g. "Relay") to set weights for ← incoming webhooks.</div>
    <div style="margin-bottom:8px; display:flex; gap:8px; flex-wrap:wrap;">
      <button onclick="sortSourcesByWeight()">Sort by Weight</button>
      <button onclick="document.getElementById('opmlInput').click()">Import OPML</button>
      <input type="file" id="opmlInput" accept=".opml,.xml" style="display:none" onchange="handleOPML(this)">
    </div>
    <div id="sourceList"></div>
    <button onclick="addSource()" style="margin-top:8px">+ Add Source</button>
  </div>

  <!-- INCLUDE / EXCLUDE -->
<h2 onclick="toggleSection(this)"><span>Include / Exclude</span></h2>  <div class="section-body">
    <div id="incRules"></div>
    <button onclick="addRule('incRules')" style="margin-top:8px">+ Add Include Rule</button>
    <div id="excRules" style="margin-top:16px"></div>
    <button onclick="addRule('excRules')" style="margin-top:8px">+ Add Exclude Rule</button>
  </div>

  <!-- OUTPUT WEBHOOKS -->
<h2 onclick="toggleSection(this)"><span>→ Output Webhooks</span></h2>
  <div class="section-body">
<div style="font-size:0.85em; color:#444; margin-bottom:12px;">→ Push each new item out to these URLs as it's found (checked every 30 minutes).</div>
    <div id="outWebhookList"></div>
    <button onclick="addOutWebhook()" style="margin-top:8px">+ Add Webhook</button>
  </div>

  <!-- SAVE -->
  <div style="margin-top:40px; display:flex; gap:10px">
    <button onclick="saveGate()" style="background:#0066cc; color:white; border-color:#0066cc">Save Gate</button>
  </div>
</div>

<script>
// FeedGate Admin UI v3.3
let CONFIG = { workerUrl: "" };
let IS_EDIT_MODE = false;

function setStatus(msg) { document.getElementById('feedList').innerText = msg; }

window.onload = async () => {
  try {
    const res = await fetch('/api/config');
    CONFIG = await res.json();
if (!localStorage.getItem('fg_secret')) {
      document.getElementById('loginOverlay').style.display = 'flex';
    } else { loadFeeds(); loadCronOrder(); }
  } catch (err) { setStatus("Error: API not responding."); }
};

async function doLogin() {
  const secret = document.getElementById('adminSecret').value.trim();
  if (!secret) return;
localStorage.setItem('fg_secret', secret);
  document.getElementById('loginOverlay').style.display = 'none';
  loadFeeds();
  loadCronOrder();
}

async function api(path, method = 'GET', body = null) {
  const headers = { 'X-FeedGate-Secret': localStorage.getItem('fg_secret') };
  if (body) headers['Content-Type'] = 'application/json';
  const res = await fetch(path, { method, headers, body: body ? JSON.stringify(body) : null });
  if (res.status === 401) { localStorage.removeItem('fg_secret'); location.reload(); }
  return res;
}

async function loadFeeds() {
  try {
    setStatus("Fetching feeds...");
    const res = await api('/api/feeds');
    const feeds = await res.json();
    const list = document.getElementById('feedList');
    list.innerHTML = feeds.length ? '' : 'No gates found.';
    feeds.forEach(f => {
      const d = document.createElement('div');
      d.className = 'feed-item';
      d.innerHTML = `<div class="slug-line">/${f.slug}</div>
      <div class="feed-details" id="det-${f.slug}">
        <button onclick="editGate('${f.slug}')">Edit</button>
        <button onclick="hardRefresh('${f.slug}', this)">Hard Refresh</button>
        <button onclick="copyLink('${f.slug}', this)">Copy Link</button>
        <button onclick="deleteGate('${f.slug}')" style="color:red">Delete</button>
      </div>`;
      d.onclick = (e) => { if (e.target.tagName !== 'BUTTON') { const el = document.getElementById(`det-${f.slug}`); el.style.display = el.style.display === 'block' ? 'none' : 'block'; } };
      list.appendChild(d);
    });
} catch (e) { setStatus("Error loading feeds."); }
}

let CRON_ORDER = [];
let CRON_TITLES = {};

async function loadCronOrder() {
  try {
    const [feedsRes, orderRes] = await Promise.all([
      api('/api/feeds'),
      api('/api/cron-order')
    ]);
    const feeds = await feedsRes.json();
    const orderData = await orderRes.json();
    const savedOrder = Array.isArray(orderData.order) ? orderData.order : [];
    const knownSlugs = feeds.map(f => f.slug);

    CRON_TITLES = {};
    feeds.forEach(f => { CRON_TITLES[f.slug] = f.title || f.slug; });

    let order = savedOrder.filter(s => knownSlugs.includes(s));
    knownSlugs.forEach(s => { if (!order.includes(s)) order.push(s); });

    CRON_ORDER = order;
    renderCronOrder();
  } catch (e) {
    document.getElementById('cronOrderList').innerText = "Error loading cron order.";
  }
}

function renderCronOrder() {
  const list = document.getElementById('cronOrderList');
  list.innerHTML = '';
  CRON_ORDER.forEach((slug, i) => {
    const d = document.createElement('div');
    d.className = 'row';
    d.innerHTML = `<span style="width:20px">${i + 1}.</span><button class="btn-small" onclick="moveCronRow(${i},-1)">↑</button><button class="btn-small" onclick="moveCronRow(${i},1)">↓</button><span class="cron-label" style="flex-grow:1"></span>`;
    d.querySelector('.cron-label').textContent = (CRON_TITLES[slug] || slug) + ' (/' + slug + ')';
    list.appendChild(d);
  });
}

function moveCronRow(index, dir) {
  const target = index + dir;
  if (target < 0 || target >= CRON_ORDER.length) return;
  [CRON_ORDER[index], CRON_ORDER[target]] = [CRON_ORDER[target], CRON_ORDER[index]];
  renderCronOrder();
}

async function saveCronOrder() {
  const res = await api('/api/cron-order', 'PUT', { order: CRON_ORDER });
  if (res.ok) { alert('Cron order saved.'); } else { alert('Save failed: ' + res.status); }
}

function updateWebhookInfo() {
  const slug = document.getElementById('slug').value.trim();
  const urlEl = document.getElementById('webhookUrl');
  if (slug) {
    urlEl.innerText = CONFIG.workerUrl + "/" + slug + "?secret=YOUR_SECRET";
  } else {
    urlEl.innerText = "[Enter slug first]";
  }
}

function copyWebhookUrl(btn) {
  const slug = document.getElementById('slug').value.trim();
  if (!slug) return alert("Enter a slug first");
  navigator.clipboard.writeText(CONFIG.workerUrl + "/" + slug + "?secret=YOUR_SECRET");
  flash(btn);
}

function copyPayload(btn) {
  navigator.clipboard.writeText(document.getElementById('webhookPayload').innerText);
  flash(btn);
}

function toggleSection(h2) {
  const body = h2.nextElementSibling;
  const isOpen = body.style.display === 'block';
  body.style.display = isOpen ? 'none' : 'block';
}

function closeAllSections() {
  document.querySelectorAll('#editor h2').forEach(h2 => {
    if (h2.nextElementSibling && h2.nextElementSibling.classList.contains('section-body')) {
      h2.nextElementSibling.style.display = 'none';
    }
  });
}

function showDashboard() {
  document.getElementById('editor').style.display = 'none';
  document.getElementById('dashboard').style.display = 'block';
  IS_EDIT_MODE = false;
}

function showEditor() {
  document.getElementById('dashboard').style.display = 'none';
  document.getElementById('editor').style.display = 'block';
  resetForm();
}

function resetForm() {
  document.getElementById('slug').disabled = false;
  document.getElementById('slug').value = '';
  document.getElementById('sourceList').innerHTML = '';
  addSource();
document.getElementById('incRules').innerHTML = '';
  document.getElementById('excRules').innerHTML = '';
  document.getElementById('outWebhookList').innerHTML = '';
document.getElementById('editorTitle').innerText = 'New Gate';
  document.getElementById('pTitle').value = '';
  document.getElementById('pAge').value = 30;
  document.getElementById('pMax').value = 20;
  updateWebhookInfo();
  closeAllSections();
}

async function editGate(slug) {
  IS_EDIT_MODE = true;
  const res = await api('/api/feeds/' + slug);
  const gate = await res.json();
  showEditor();
  document.getElementById('editorTitle').innerText = 'Edit Gate: ' + slug;
  document.getElementById('slug').value = slug;
  document.getElementById('slug').disabled = true;
  updateWebhookInfo();

  document.getElementById('sourceList').innerHTML = '';
  (gate.sources || []).forEach(s => addSource(s.url, s.weight));
  document.getElementById('incRules').innerHTML = '';
  (gate.rulesInclude || []).forEach(r => addRule('incRules', r));
document.getElementById('excRules').innerHTML = '';
  (gate.rulesExclude || []).forEach(r => addRule('excRules', r));

  document.getElementById('outWebhookList').innerHTML = '';
  (gate.outputWebhooks || []).forEach(w => addOutWebhook(w.name, w.url, w.secret));

document.getElementById('pTitle').value = gate.proxy?.title || '';
  document.getElementById('pAge').value = gate.ageLimit ?? 30;
  document.getElementById('pMax').value = gate.maxItems ?? 20;
  closeAllSections();
}

async function saveGate() {
  const slug = document.getElementById('slug').value.trim();
  if (!slug) return alert("Slug required");
const titleVal = document.getElementById('pTitle').value.trim();
  const ageVal = document.getElementById('pAge').value;
  const maxVal = document.getElementById('pMax').value;
  
const gate = {
    proxy: { title: titleVal },
    ageLimit: ageVal === "" ? 0 : parseInt(ageVal),
    maxItems: maxVal === "" ? 20 : parseInt(maxVal),
    sources: Array.from(document.querySelectorAll('#sourceList .row')).map(r => ({ url: r.querySelector('.src-url').value, weight: parseInt(r.querySelector('.src-weight').value) })).filter(s => s.url),
    rulesInclude: Array.from(document.getElementById('incRules').children).map(r => ({ logic: r.querySelector('.log')?.value || 'Or', key: r.querySelector('.k').value, target: r.querySelector('.t').value })).filter(x => x.key),
    rulesExclude: Array.from(document.getElementById('excRules').children).map(r => ({ logic: r.querySelector('.log')?.value || 'Or', key: r.querySelector('.k').value, target: r.querySelector('.t').value })).filter(x => x.key),
    outputWebhooks: Array.from(document.getElementById('outWebhookList').children).map(r => ({ name: r.querySelector('.owh-name').value.trim(), url: r.querySelector('.owh-url').value.trim(), secret: r.querySelector('.owh-sec').value.trim() })).filter(w => w.url)
  };
  
  const res = await api('/api/feeds' + (IS_EDIT_MODE ? '/' + slug : ''), IS_EDIT_MODE ? 'PUT' : 'POST', { slug, gate });
  if (res.status === 409) {
    if (confirm("Slug already exists. Overwrite?")) {
      const res2 = await api('/api/feeds/' + slug, 'PUT', { slug, gate });
      if (res2.ok) { showDashboard(); loadFeeds(); } else { alert("Save failed: " + res2.status); }
    }
  } else if (res.ok) { showDashboard(); loadFeeds(); }
  else { alert("Save failed: " + res.status); }
}

async function hardRefresh(slug, btn) {
  const url = CONFIG.workerUrl + "/" + slug;
  await fetch(url, { headers: { 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' } });
  const old = btn.innerText; btn.innerText = 'Refreshed!'; setTimeout(() => btn.innerText = old, 2000);
}

function handleOPML(input) {
  const file = input.files[0];
  if (!file) return;
  const reader = new FileReader();
  reader.onload = function(e) {
    const parser = new DOMParser();
    const xml = parser.parseFromString(e.target.result, "text/xml");
    const outlines = xml.querySelectorAll("outline[xmlUrl]");
    const existingUrls = new Set(Array.from(document.querySelectorAll('.src-url')).map(i => i.value.trim().toLowerCase()));
    let count = 0;
    outlines.forEach(o => {
      const url = o.getAttribute("xmlUrl").trim();
      if (url && !existingUrls.has(url.toLowerCase())) {
        addSource(url, 1);
        existingUrls.add(url.toLowerCase());
        count++;
      }
    });
    alert("Imported " + count + " new sources.");
    input.value = '';
  };
  reader.readAsText(file);
}

function sortSourcesByWeight() {
  const list = document.getElementById('sourceList');
  const rows = Array.from(list.children);
  rows.sort((a, b) => {
    const wA = parseInt(a.querySelector('.src-weight').value) || 0;
    const wB = parseInt(b.querySelector('.src-weight').value) || 0;
    return wB - wA;
  });
  list.innerHTML = '';
  rows.forEach(r => list.appendChild(r));
}

function moveRow(btn, dir) {
  const row = btn.parentElement;
  if (row) {
    if (dir === -1 && row.previousElementSibling) row.parentNode.insertBefore(row, row.previousElementSibling);
    else if (dir === 1 && row.nextElementSibling) row.parentNode.insertBefore(row.nextElementSibling, row);
  }
}

function addSource(u='', w=1) {
  const d = document.createElement('div');
  d.className = 'row';
  d.innerHTML = `<span class="src-num"></span><button class="btn-small" onclick="moveRow(this,-1)">↑</button><button class="btn-small" onclick="moveRow(this,1)">↓</button><input type="text" class="src-url" value="${u}" placeholder="URL or Webhook Name" style="flex-grow:1"><input type="number" class="src-weight" value="${w}" style="width:50px" title="Weight"><button class="btn-small" onclick="this.parentElement.remove()">−</button>`;
  document.getElementById('sourceList').appendChild(d);
  renumberSources();
}

function renumberSources() {
  document.querySelectorAll('#sourceList .row').forEach((row, i) => {
    const numEl = row.querySelector('.src-num');
    if (numEl) numEl.textContent = (i + 1) + '.';
  });
}

function addRule(id, r={logic:'Or',key:'',target:'title'}) {
  const c = document.getElementById(id);
  const f = c.children.length === 0;
  const d = document.createElement('div');
  d.className = 'row';
  d.innerHTML = `<div style="width:75px">${f ? '' : `<select class="log"><option ${r.logic==='Or'?'selected':''}>Or</option><option ${r.logic==='And'?'selected':''}>And</option></select>`}</div><input type="text" class="k" value="${r.key}" style="flex-grow:1"><select class="t" style="width:110px"><option value="title" ${r.target==='title'?'selected':''}>Title</option><option value="text" ${r.target==='text'?'selected':''}>Full Text</option><option value="url" ${r.target==='url'?'selected':''}>Source URL</option></select><button class="btn-small" onclick="this.parentElement.remove()">−</button>`;
  c.appendChild(d);
}

function addOutWebhook(name='', url='', secret='') {
  const d = document.createElement('div');
  d.className = 'row';
  d.innerHTML = `<input type="text" class="owh-name" value="${name}" placeholder="Name" style="width:120px"><input type="text" class="owh-url" value="${url}" placeholder="URL" style="flex-grow:1"><input type="text" class="owh-sec" value="${secret}" placeholder="Secret" style="width:120px"><button class="btn-small" onclick="this.parentElement.remove()">−</button>`;
  document.getElementById('outWebhookList').appendChild(d);
}

async function deleteGate(slug) {
  if (confirm("Delete " + slug + "?")) { await api('/api/feeds/' + slug, 'DELETE'); loadFeeds(); }
}

function copyLink(slug, btn) { navigator.clipboard.writeText(CONFIG.workerUrl + '/' + slug); flash(btn); }
function flash(btn) { const o = btn.innerText; btn.innerText = 'Copied!'; setTimeout(() => btn.innerText = o, 2000); }
</script>
</body>
</html>