ep_rss 11.0.26 → 11.0.28

package/AGENTS.md

@@ -17,13 +17,14 @@ ep_rss/
 ├── client.js
 ├── ep.json
 ├── index.js
+├── locales/
+│   └── en.json
 ├── package.json
 ├── static/
-│   ├── img/
-│   ├── tests/
+│   ├── css/exportColumn.css
+│   └── tests/
 ├── templates/
-│   ├── embedFrame.ejs
-│   ├── embedFrame.html
+│   └── exportColumn.ejs
 ```
 
 ## Helpers used
@@ -59,6 +60,6 @@ pnpm --filter ep_etherpad-lite run test-ui
 
 ## Quick reference: hooks declared in `ep.json`
 
-* Server: `eejsBlock_htmlHead`, `expressCreateServer`, `eejsBlock_embedPopup`
+* Server: `eejsBlock_htmlHead`, `expressCreateServer`, `eejsBlock_exportColumn`, `eejsBlock_styles`
 
 When adding a hook, register it in both `ep.json` *and* the matching `exports.<hook> = ...` in the JS file.

package/client.js

@@ -2,8 +2,14 @@
 
 const eejs = require('ep_etherpad-lite/node/eejs');
 
-exports.eejsBlock_embedPopup = (hookName, args, cb) => {
+exports.eejsBlock_exportColumn = (hookName, args, cb) => {
   const feedURL = `..${args.renderContext.req.url}/feed`;
-  args.content += eejs.require('ep_rss/templates/embedFrame.ejs', {feed: feedURL});
+  args.content += eejs.require('ep_rss/templates/exportColumn.ejs', {feed: feedURL});
+  return cb();
+};
+
+exports.eejsBlock_styles = (hookName, args, cb) => {
+  args.content +=
+      '<link rel="stylesheet" href="/static/plugins/ep_rss/static/css/exportColumn.css">';
   return cb();
 };

package/ep.json

@@ -5,7 +5,8 @@
       "hooks": {
         "eejsBlock_htmlHead": "ep_rss/index",
         "expressCreateServer" : "ep_rss/index:registerRoute",
-        "eejsBlock_embedPopup": "ep_rss/client:eejsBlock_embedPopup"
+        "eejsBlock_exportColumn": "ep_rss/client:eejsBlock_exportColumn",
+        "eejsBlock_styles": "ep_rss/client:eejsBlock_styles"
       }
     }
   ]

package/index.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {Feed} = require('feed');
 const API = require('ep_etherpad-lite/node/db/API');
 const padManager = require('ep_etherpad-lite/node/db/PadManager');
 const settings = require('ep_etherpad-lite/node/utils/Settings');
@@ -9,9 +10,13 @@ if (!settings.rss) {
   console.log('ep_rss settings have not been configured');
 }
 
-const staleTime = settings.rss.staleTime || 300000; // 5 minutes, value should be set in settings
-const feeds = {}; // A nasty global
+// How long to serve a cached feed before regenerating. Bumped on every
+// pad edit anyway via the lastEdited check below, so this only affects
+// pads that haven't been edited recently.
+const staleTime = settings.rss.staleTime || 300000;
 
+// Per-pad cache: { lastEdited: number, body: string }.
+const feeds = {};
 
 exports.eejsBlock_htmlHead = (hookName, args, cb) => {
   args.content +=
@@ -28,79 +33,45 @@ exports.registerRoute = (hookName, args, cb) => {
   args.app.get('/p/:padId/atom.xml', redirectToFeed);
 
   args.app.get('/p/:padId/feed', async (req, res) => {
-    const fullURL = `${req.protocol}://${req.get('host')}${req.url}`;
     const padId = req.params.padId;
-    const padURL = `${req.protocol}://${req.get('host')}/p/${padId}`;
-    const dateString = new Date();
-    let isPublished = false; // is this item already published?
-    let text;
+    const origin = `${req.protocol}://${req.get('host')}`;
+    const padURL = `${origin}/p/${padId}`;
+    // Strip query string so the atom:self link matches the URL feed
+    // readers actually fetched (e.g. when they tack on cache-busters).
+    const feedURL = `${origin}${req.url.split('?')[0]}`;
 
-    /* When was this pad last edited and should we publish an RSS update? */
-    const message = await API.getLastEdited(padId);
-    const currTS = new Date().getTime();
-    if (!feeds[padId]) {
-      feeds[padId] = {};
+    const {lastEdited} = await API.getLastEdited(padId);
+    const now = Date.now();
+    const cached = feeds[padId];
+    if (cached && cached.lastEdited === lastEdited && now - cached.builtAt < staleTime) {
+      res.type('application/rss+xml');
+      res.send(cached.body);
+      return;
     }
 
-    // was the pad edited within the last 5 minutes?
-    if (currTS - message.lastEdited < staleTime) {
-      isPublished = isAlreadyPublished(padId, message.lastEdited);
+    const pad = await padManager.getPad(padId);
+    const feed = new Feed({
+      title: padId,
+      description: `Etherpad feed for ${padId}`,
+      id: padURL,
+      link: padURL,
+      language: 'en-us',
+      feedLinks: {rss: feedURL},
+      updated: new Date(lastEdited),
+    });
+    feed.addItem({
+      title: padId,
+      id: `${padURL}#${lastEdited}`,
+      link: padURL,
+      description: pad.text(),
+      date: new Date(lastEdited),
+    });
 
-      if (!isPublished) { // If it's not already published and it's gone stale
-        feeds[padId].lastEdited = message.lastEdited; // Add it to the timer object
-      }
-    } else {
-      if (!feeds[padId].feed) { // If it's not already stored in memory
-        console.debug('RSS Feed not already in memory so writing memory', feeds);
-        isPublished = false;
-        feeds[padId].lastEdited = message.lastEdited; // Add it to the timer object
-      } else {
-        isPublished = true;
-      }
-    }
-    if (!isPublished) {
-      const pad = await padManager.getPad(padId);
-      text = safe_tags(pad.text()).replace(/\n/g, '<br/>');
-    }
-
-    if (isPublished) {
-      console.debug(`Sending RSS from memory for ${padId}`);
-      res.contentType('rss');
-      res.send(feeds[padId].feed);
-    } else {
-      console.debug(`Building RSS for ${padId}`);
-      res.contentType('rss');
-      args.content = '<rss version="2.0" \n';
-      args.content += '   xmlns:content="http://purl.org/rss/1.0/modules/content/"\n';
-      args.content += '   xmlns:atom="http://www.w3.org/2005/Atom"\n';
-      args.content += '>\n';
-      args.content += '<channel>\n';
-      args.content += `<title>${padId}</title>\n`;
-      args.content += `<atom:link href="${fullURL}" rel="self" type="application/rss+xml" />`;
-      args.content += `<link>${padURL}</link>\n`;
-      args.content += '<description/>\n';
-      args.content += '<language>en-us</language>\n';
-      args.content += `<pubDate>${dateString}</pubDate>\n`;
-      args.content += `<lastBuildDate>${dateString}</lastBuildDate>\n`;
-      args.content += '<item>\n';
-      args.content += '<title>\n';
-      args.content += `${padId}\n`;
-      args.content += '</title>\n';
-      args.content += '<description>\n';
-      args.content += `<![CDATA[${text}]]>\n`;
-      args.content += '</description>\n';
-      args.content += `<link>${padURL}</link>\n`;
-      args.content += '</item>\n';
-      args.content += '</channel>\n';
-      args.content += '</rss>';
-      feeds[padId].feed = args.content;
-      res.send(args.content); // Send it to the requester
-    }
+    const body = feed.rss2();
+    feeds[padId] = {lastEdited, builtAt: now, body};
+    res.type('application/rss+xml');
+    res.send(body);
   });
+
   cb();
 };
-
-const safe_tags =
-    (str) => str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-const isAlreadyPublished = (padId, editTime) => (feeds[padId] === editTime);

package/locales/en.json

@@ -0,0 +1,4 @@
+{
+  "ep_rss.exportrssa.title": "RSS feed of this pad",
+  "ep_rss.exportrss": "RSS"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ep_rss",
   "description": "Get an RSS feed of pad updates",
-  "version": "11.0.26",
+  "version": "11.0.28",
   "author": {
     "name": "John McLear",
     "email": "john@mclear.co.uk",
@@ -19,6 +19,9 @@
     "type": "individual",
     "url": "https://etherpad.org/"
   },
+  "dependencies": {
+    "feed": "^5.2.1"
+  },
   "devDependencies": {
     "eslint": "^8.57.1",
     "eslint-config-etherpad": "^4.0.5",

package/static/css/exportColumn.css

@@ -0,0 +1,24 @@
+/*
+ * SVG export-icon styling. The other export buttons render a Fontello
+ * glyph via the .exporttype:before / .buttonicon-* pseudo-element; we
+ * use an inline SVG instead so the icon survives without registering
+ * an extra font character. Sized at 22px to match the heuristic
+ * height of the buttonicon font row, kept orange so RSS readers still
+ * recognise it at a glance.
+ */
+#exportrssa .ep_rss_export_icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  margin-right: 10px;
+  color: #f26522;
+  vertical-align: middle;
+}
+
+#exportrssa .ep_rss_export_icon svg {
+  width: 100%;
+  height: 100%;
+  fill: currentColor;
+}

package/static/tests/frontend-new/specs/export-link.spec.ts

@@ -0,0 +1,43 @@
+import {expect, test} from '@playwright/test';
+import {goToNewPad} from 'ep_etherpad-lite/tests/frontend-new/helper/padHelper';
+
+test.describe('ep_rss export-column link', () => {
+  test('renders the RSS link inside the Import/Export column', async ({page}) => {
+    await goToNewPad(page);
+    const link = page.locator('#exportColumn a#exportrssa');
+    await expect(link).toHaveCount(1);
+    await expect(link).toHaveAttribute('data-l10n-id', 'ep_rss.exportrssa.title');
+    await expect(link).toHaveAttribute('target', '_blank');
+    await expect(link).toHaveAttribute('rel', 'noopener');
+    const href = await link.getAttribute('href');
+    expect(href).toMatch(/\/feed$/);
+    await expect(link.locator('span#exportrss svg')).toHaveCount(1);
+  });
+
+  test('localized title attribute resolves via html10n', async ({page}) => {
+    await goToNewPad(page);
+    const link = page.locator('#exportrssa');
+    await expect.poll(
+      async () => link.getAttribute('title'),
+      {timeout: 5000},
+    ).toBe('RSS feed of this pad');
+  });
+
+  test('clicking the link reaches /p/<pad>/feed', async ({page, request}) => {
+    await goToNewPad(page);
+    const href = await page.locator('#exportrssa').getAttribute('href');
+    expect(href).toBeTruthy();
+    const resolved = new URL(href!, page.url()).toString();
+    const res = await request.get(resolved);
+    expect(res.status()).toBe(200);
+    expect(res.headers()['content-type']).toContain('application/rss+xml');
+  });
+
+  test('share/embed popup no longer carries an RSS block', async ({page}) => {
+    await goToNewPad(page);
+    // The legacy embedFrame.ejs put `<a class="rssfeed">` inside #embed.
+    // Verify nothing in #embed references the feed any more.
+    const stale = page.locator('#embed a.rssfeed, #embed a[href*="feed"]');
+    await expect(stale).toHaveCount(0);
+  });
+});

package/static/tests/frontend-new/specs/feed.spec.ts

@@ -25,21 +25,79 @@ test.describe('ep_rss feed', () => {
     expect(res.status()).toBe(200);
     expect(res.headers()['content-type']).toContain('application/rss+xml');
     const body = await res.text();
-    expect(body).toMatch(/^<rss /);
+    expect(body).toMatch(/^<\?xml version="1\.0" encoding="utf-8"\?>\n<rss /);
+    // Channel title is a plain element; item title is CDATA-wrapped by
+    // the feed library. Both must carry the pad id.
     expect(body).toContain(`<title>${padId}</title>`);
+    expect(body).toContain(`<title><![CDATA[${padId}]]></title>`);
     expect(body).toContain(marker);
     expect(body.trim().endsWith('</rss>')).toBe(true);
   });
 
-  test('escapes HTML special characters in the description', async ({page, request}) => {
+  test('uses RFC-822 dates for pubDate and lastBuildDate (feedvalidator.org)', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'date check');
+    await page.waitForTimeout(1200);
+    const body = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    // "Mon, 18 May 2026 09:53:13 GMT" — what Date.toUTCString() emits and
+    // what feedvalidator.org requires per RSS 2.0's RFC-822 rule.
+    const RFC822 = /^[A-Z][a-z]{2}, \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+    const pub = body.match(/<pubDate>([^<]+)<\/pubDate>/g) || [];
+    const build = body.match(/<lastBuildDate>([^<]+)<\/lastBuildDate>/);
+    expect(pub.length).toBeGreaterThanOrEqual(1);
+    for (const tag of pub) {
+      const value = tag.replace(/<\/?pubDate>/g, '');
+      expect(value, `pubDate "${value}"`).toMatch(RFC822);
+    }
+    expect(build).not.toBeNull();
+    expect(build![1]).toMatch(RFC822);
+  });
+
+  test('item carries a stable non-permalink guid', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'guid check');
+    await page.waitForTimeout(1200);
+
+    const first = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    const m = first.match(/<guid isPermaLink="false">([^<]+)<\/guid>/);
+    expect(m, 'guid element missing').not.toBeNull();
+    expect(m![1]).toContain(`/p/${padId}#`);
+
+    // Polling the same pad without editing must return the same guid so
+    // feed readers don't show a duplicate item every fetch.
+    const second = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
+    const m2 = second.match(/<guid isPermaLink="false">([^<]+)<\/guid>/);
+    expect(m2![1]).toBe(m![1]);
+  });
+
+  test('atom:self link drops the query string so it matches the document URL', async ({page, request}) => {
+    await goToNewPad(page);
+    const padId = padIdFromUrl(page.url());
+    await writeToPad(page, 'self-ref check');
+    await page.waitForTimeout(1200);
+    const body = await (await request.get(`${BASE_URL}/p/${padId}/feed?_=cachebust`)).text();
+    const self = body.match(/<atom:link href="([^"]+)" rel="self"/);
+    expect(self).not.toBeNull();
+    expect(self![1]).toBe(`${BASE_URL}/p/${padId}/feed`);
+  });
+
+  test('pad text with XML-significant characters is CDATA-wrapped', async ({page, request}) => {
     await goToNewPad(page);
     const padId = padIdFromUrl(page.url());
     await writeToPad(page, 'tags <b>&</b>');
     await page.waitForTimeout(1200);
 
     const body = await (await request.get(`${BASE_URL}/p/${padId}/feed`)).text();
-    expect(body).toContain('&lt;b&gt;&amp;&lt;/b&gt;');
-    expect(body).not.toContain('<b>&</b>');
+    // CDATA section protects raw `<` and `&` from XML parsing, so the
+    // feed library passes pad text through verbatim instead of double-
+    // encoding. The body must (a) be well-formed XML — that's covered
+    // implicitly by every test that parses the response — and (b)
+    // include the text inside the CDATA section.
+    const descMatch = body.match(/<description><!\[CDATA\[([\s\S]*?)\]\]><\/description>/);
+    expect(descMatch, 'item description must be CDATA-wrapped').not.toBeNull();
+    expect(descMatch![1]).toContain('tags <b>&</b>');
   });
 
   for (const alias of ['rss', 'feed.rss', 'atom.xml']) {

package/templates/exportColumn.ejs

@@ -0,0 +1,7 @@
+<a id="exportrssa" data-l10n-id="ep_rss.exportrssa.title" target="_blank" rel="noopener" class="exportlink" href="<%= feed %>">
+  <span class="exporttype ep_rss_export_icon" id="exportrss" data-l10n-id="ep_rss.exportrss" aria-hidden="true">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" focusable="false" aria-hidden="true">
+      <path d="M5 4.5a1.5 1.5 0 0 1 1.5-1.5C14.4 3 21 9.6 21 17.5a1.5 1.5 0 0 1-3 0C18 11.3 12.7 6 6.5 6A1.5 1.5 0 0 1 5 4.5Zm0 6a1.5 1.5 0 0 1 1.5-1.5C11.7 9 16 13.3 16 18.5a1.5 1.5 0 0 1-3 0C13 14.9 10.1 12 6.5 12A1.5 1.5 0 0 1 5 10.5ZM6.5 16a2 2 0 1 1 0 4 2 2 0 0 1 0-4Z"/>
+    </svg>
+  </span>
+</a>

package/templates/embedFrame.ejs

@@ -1,8 +0,0 @@
-<br>
-<h2>Rss Feeds</h2>
-<p>
-<a class="rssfeed" href="<%= feed%>" title="Pad Feed">
-<img src="../static/plugins/ep_rss/static/img/rss.gif">
-</a>
-
-</p>

package/templates/embedFrame.html

@@ -1 +0,0 @@
-<a class="rssfeed" href="feed">RSS Feed</a>