tibodog 0.1.2 → 0.1.3

package/app/Tests/TiboDogTests/CodexUsageTests.swift

@@ -0,0 +1,77 @@
+import XCTest
+@testable import TiboDog
+
+final class CodexUsageTests: XCTestCase {
+    func testPrefersCodexBucketAndDecodesResetSeconds() throws {
+        let result = try CodexUsageAPI.decode([
+            "rateLimits": ["primary": ["usedPercent": 99]],
+            "rateLimitsByLimitId": [
+                "codex": ["planType": "plus", "primary": ["usedPercent": 63, "windowDurationMins": 300, "resetsAt": 1789194640],
+                          "secondary": ["usedPercent": 16, "windowDurationMins": 10080]],
+                "other": ["primary": ["usedPercent": 100]]
+            ]
+        ])
+        XCTAssertEqual(result.usage.fiveHour?.utilization, 63)
+        XCTAssertEqual(result.usage.fiveHour?.resetsAt, Date(timeIntervalSince1970: 1789194640))
+        XCTAssertEqual(result.usage.fiveHour?.durationLabel, "5H")
+        XCTAssertEqual(result.usage.sevenDay?.durationLabel, "7D")
+        XCTAssertEqual(result.plan, "plus")
+        XCTAssertNil(result.usage.sevenDayOpus)
+        XCTAssertNil(result.resetCredits)
+    }
+
+    func testDecodesResetCredits() throws {
+        let result = try CodexUsageAPI.decode([
+            "rateLimits": ["primary": ["usedPercent": 1, "windowDurationMins": 300]],
+            "rateLimitResetCredits": ["availableCount": 2]
+        ])
+        XCTAssertEqual(result.resetCredits, 2)
+    }
+
+    func testLegacySingleWindowAndNonStandardDuration() throws {
+        let result = try CodexUsageAPI.decode(["rateLimits": ["primary": ["usedPercent": 0, "windowDurationMins": 15]]])
+        XCTAssertEqual(result.usage.fiveHour?.percentText, "0%")
+        XCTAssertEqual(result.usage.fiveHour?.durationLabel, "15M")
+        XCTAssertNil(result.usage.sevenDay)
+        XCTAssertNil(result.usage.fiveHour?.resetsAt)
+    }
+
+    func testMissingUsageIsNotZeroAndOtherBucketIsNotCodex() {
+        XCTAssertThrowsError(try CodexUsageAPI.decode(["rateLimits": NSNull()]))
+        XCTAssertThrowsError(try CodexUsageAPI.decode(["rateLimits": ["primary": ["resetsAt": 123]]]))
+        XCTAssertThrowsError(try CodexUsageAPI.decode(["rateLimitsByLimitId": ["other": ["primary": ["usedPercent": 12]]]]))
+    }
+
+    func testInvalidPercentageAndClamping() throws {
+        XCTAssertThrowsError(try CodexUsageAPI.decode(["rateLimits": ["primary": ["usedPercent": Double.nan]]]))
+        let result = try CodexUsageAPI.decode(["rateLimits": ["primary": ["usedPercent": 110]]])
+        XCTAssertEqual(result.usage.fiveHour?.fraction, 1)
+    }
+
+    func testClaudeDecoderStillWorks() throws {
+        let data = Data(#"{"five_hour":{"utilization":42,"resets_at":"2026-09-12T12:00:00Z"},"seven_day":{"utilization":71},"seven_day_opus":{"utilization":18}}"#.utf8)
+        let usage = try Usage(json: data)
+        XCTAssertEqual(usage.fiveHour?.utilization, 42)
+        XCTAssertNotNil(usage.fiveHour?.resetsAt)
+        XCTAssertEqual(usage.sevenDayOpus?.utilization, 18)
+    }
+
+    func testLiveCodexReadWhenRequested() throws {
+        guard ProcessInfo.processInfo.environment["TIBODOG_TEST_LIVE_CODEX"] == "1" else {
+            throw XCTSkip("Set TIBODOG_TEST_LIVE_CODEX=1 to check the installed Codex login.")
+        }
+        let result = try CodexUsageAPI.fetch()
+        XCTAssertTrue(result.usage.fiveHour != nil || result.usage.sevenDay != nil)
+    }
+}
+
+final class DogLinkTests: XCTestCase {
+    func testOnlyPostsOnXOpen() {
+        XCTAssertTrue(isPostURL(URL(string: "https://x.com/thsottiaux/status/2114588174249071102")!))
+        XCTAssertTrue(isPostURL(URL(string: "https://twitter.com/a/status/123456")!))
+        for bad in ["file:///System/Applications/Calculator.app", "http://x.com/a/status/1", "vscode://x/status/1",
+                    "https://x.com.evil.com/a/status/1", "https://evil.com/x.com/status/1", "https://x.com/settings"] {
+            XCTAssertFalse(isPostURL(URL(string: bad)!), bad)
+        }
+    }
+}

package/bin/tibodog.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util';
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { isResetPost } from '../src/detect.js';
 import { xSource, rssSource, RateLimited } from '../src/sources.js';
 import { playBark, notify, openUrl } from '../src/bark.js';
 import { showDog, log, barking, SLEEPING, WATCHING } from '../src/dog.js';
 import { detectLang, getMessages } from '../src/i18n.js';
-import { ensureWidget, launchWidget, widgetRunning, widgetSupported, installApp, writeAlert } from '../src/widget.js';
+import { ensureWidget, launchWidget, widgetRunning, widgetSupported, installApp, writeAlert, DIR } from '../src/widget.js';
 
-const { values: opt } = parseArgs({
-  options: {
+// Anything that slips through still gets logged instead of killing the watcher.
+process.on('unhandledRejection', (e) => log(`⚠️  ${e?.message ?? e}`));
+
+const options = {
     user: { type: 'string', default: process.env.TIBODOG_USER ?? 'thsottiaux' },
     rss: { type: 'string', default: process.env.TIBODOG_RSS },
     interval: { type: 'string', default: process.env.TIBODOG_INTERVAL },
@@ -26,8 +27,17 @@ const { values: opt } = parseArgs({
     once: { type: 'boolean', default: false },
     test: { type: 'boolean', default: false },
     help: { type: 'boolean', short: 'h', default: false },
-  },
-});
+};
+
+let opt;
+try {
+  ({ values: opt } = parseArgs({ options }));
+} catch (e) {
+  const t = getMessages(detectLang());
+  console.error(`🐕 ${e.message}\n`);
+  console.log(t.help);
+  process.exit(2);
+}
 
 const lang = detectLang(opt.lang);
 const t = getMessages(lang);
@@ -37,19 +47,35 @@ if (opt.help) {
   process.exit(0);
 }
 
+// An X handle: also names the state file, so nothing else gets through.
+if (!/^[A-Za-z0-9_]{1,15}$/.test(opt.user)) {
+  console.error(`🐕 --user: "${opt.user}" isn't an X handle`);
+  process.exit(2);
+}
+const keywords = opt.keyword.map((k) => k.trim()).filter(Boolean);
+
 const barks = Math.max(1, Number(opt.barks) || 1);
 const useWidget = widgetSupported() && !opt['no-widget'];
 
 // Puts the notch widget (usage, Now Playing, the dog) on screen, building it on first run.
 let widgetLaunchedAt = 0;
+let widgetBroken = false;
 async function startWidget() {
-  // Just opened: it can take a moment to show up as running.
-  if (!useWidget || widgetRunning() || Date.now() - widgetLaunchedAt < 30_000) return;
-  const { app, error } = await ensureWidget({ onBuild: () => log(t.widgetBuilding) });
-  if (error) {
-    log(`${t.widgetFailed}\n${error}`);
+  // Just opened: it can take a moment to show up as running. A failed build isn't retried this run.
+  if (!useWidget || widgetBroken || widgetRunning() || Date.now() - widgetLaunchedAt < 30_000) return;
+  let result;
+  try {
+    result = await ensureWidget({ onBuild: () => log(t.widgetBuilding) });
+  } catch (e) {
+    result = { error: e.message };
+  }
+  const { app, error, fallback } = result;
+  if (error) log(`${t.widgetFailed}\n${error}`);
+  if (!app) {
+    widgetBroken = true;
     return;
   }
+  if (fallback) widgetBroken = true; // running the last good build; don't rebuild on every alert
   launchWidget(app);
   widgetLaunchedAt = Date.now();
   log(t.widgetUp);
@@ -76,17 +102,21 @@ async function alert(post) {
   notify(t.notifyTitle, post.text.slice(0, 180));
   if (opt.open && post.url) openUrl(post.url);
   // The widget picks this up and barks in the notch until it's read.
-  writeAlert({
-    id: post.id ?? `test-${Date.now()}`,
-    title: t.alertTitle,
-    body: post.text,
-    url: post.url,
-    woof: t.alertWoof,
-    open: t.alertOpen,
-    postedAt: post.createdAt,
-  });
+  try {
+    writeAlert({
+      id: post.id ?? `test-${Date.now()}`,
+      title: t.alertTitle,
+      body: post.text,
+      url: post.url,
+      woof: t.alertWoof,
+      open: t.alertOpen,
+      postedAt: post.createdAt,
+    });
+  } catch (e) {
+    log(`⚠️  ${e.message}`);
+  }
+  await playBark(barks, opt.sound); // the bark never waits on the widget
   await startWidget(); // in case it was quit
-  await playBark(barks, opt.sound);
 }
 
 if (opt.test) {
@@ -94,14 +124,15 @@ if (opt.test) {
   process.exit(0);
 }
 
-const statePath = join(process.env.TIBODOG_HOME ?? join(homedir(), '.tibodog'), `${opt.user}.json`);
+const statePath = join(DIR, `${opt.user}.json`);
 const seen = new Set((() => {
   try {
-    return JSON.parse(readFileSync(statePath, 'utf8')).seen ?? [];
+    const saved = JSON.parse(readFileSync(statePath, 'utf8')).seen;
+    return Array.isArray(saved) ? saved.map(String) : [];
   } catch {
-    return null;
+    return [];
   }
-})() ?? []);
+})());
 const firstRun = seen.size === 0;
 
 function save() {
@@ -114,7 +145,7 @@ await startWidget();
 let source;
 try {
   source = opt.rss
-    ? rssSource({ url: opt.rss })
+    ? rssSource({ url: opt.rss, username: opt.user })
     : xSource({ username: opt.user, bearerToken: process.env.X_BEARER_TOKEN, missingTokenMessage: t.noToken });
 } catch (e) {
   showDog(SLEEPING);
@@ -122,7 +153,9 @@ try {
   process.exit(1);
 }
 
-const intervalMs = (Number(opt.interval) || (opt.rss ? 60 : 300)) * 1000;
+// Between 15 seconds and a day: anything else would hammer the feed or overflow setTimeout.
+const seconds = Number(opt.interval) || (opt.rss ? 60 : 300);
+const intervalMs = Math.min(Math.max(seconds, 15), 86_400) * 1000;
 let primed = !firstRun || opt['bark-old'];
 
 async function tick() {
@@ -131,14 +164,15 @@ async function tick() {
   let barked = 0;
   for (const p of fresh) {
     seen.add(p.id);
-    if (primed && isResetPost(p.text, opt.keyword)) {
+    if (primed && isResetPost(p.text, keywords)) {
       barked++;
       await alert(p);
     }
   }
   if (!primed) log(t.primed(posts.length));
   else if (fresh.length && !barked) log(t.quiet(fresh.length));
-  primed = true;
+  // An empty first fetch (a mirror's error page) doesn't count: priming waits for real posts.
+  if (posts.length) primed = true;
   save();
 }
 
@@ -149,7 +183,9 @@ while (true) {
   let wait = intervalMs;
   try {
     await tick();
+    process.exitCode = 0;
   } catch (e) {
+    process.exitCode = 1; // --once: let cron see a failed check
     if (e instanceof RateLimited) {
       wait = Math.max(intervalMs, e.retryAt - Date.now() + 1000);
       log(t.rateLimited(Math.round(wait / 1000)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tibodog",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A notch widget (Claude Code/Codex usage, Now Playing) with a dog that barks when Tibo (@thsottiaux) resets the Codex limits on X",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
     "app/Package.swift",
     "app/LICENSE",
     "app/Sources",
+    "app/Tests",
     "app/Resources",
     "app/Scripts",
     "app/Vendor",
@@ -25,7 +26,7 @@
     "test": "node --test test/*.test.js"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=18.11"
   },
   "keywords": [
     "codex",

package/src/bark.js

@@ -1,10 +1,11 @@
 // Plays the bundled bark recording, or a synthesized bark as a fallback.
 
 import { spawn } from 'node:child_process';
-import { writeFileSync, existsSync } from 'node:fs';
+import { writeFileSync, existsSync, mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isPostUrl } from './sources.js';
 
 const RATE = 22050;
 
@@ -58,7 +59,8 @@ export function makeBarkWav(count = 2) {
 function players(file) {
   if (process.platform === 'darwin') return [['afplay', [file]]];
   if (process.platform === 'win32') {
-    return [['powershell', ['-NoProfile', '-c', `(New-Object Media.SoundPlayer '${file}').PlaySync()`]]];
+    // The path goes in through the environment, so a quote in it can't change the command.
+    return [['powershell', ['-NoProfile', '-c', '(New-Object Media.SoundPlayer $env:TIBODOG_WAV).PlaySync()'], { TIBODOG_WAV: file }]];
   }
   return [
     ['paplay', [file]],
@@ -67,11 +69,16 @@ function players(file) {
   ];
 }
 
-function run(cmd, args) {
+// Never throws: a missing player, a bad argument or a crash just means "didn't work".
+function run(cmd, args, env) {
   return new Promise((resolve) => {
-    const p = spawn(cmd, args, { stdio: 'ignore' });
-    p.on('error', () => resolve(false));
-    p.on('exit', (code) => resolve(code === 0));
+    try {
+      const p = spawn(cmd, args, { stdio: 'ignore', env: env ? { ...process.env, ...env } : undefined });
+      p.on('error', () => resolve(false));
+      p.on('exit', (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
   });
 }
 
@@ -82,15 +89,15 @@ let cached = null;
 
 function synthFile() {
   if (!cached) {
-    cached = join(tmpdir(), `tibodog-bark-${process.pid}.wav`);
+    cached = join(mkdtempSync(join(tmpdir(), 'tibodog-')), 'bark.wav');
     writeFileSync(cached, makeBarkWav(3));
   }
   return cached;
 }
 
 async function playOnce(file) {
-  for (const [cmd, args] of players(file)) {
-    if (await run(cmd, args)) return true;
+  for (const [cmd, args, env] of players(file)) {
+    if (await run(cmd, args, env)) return true;
   }
   return false;
 }
@@ -119,7 +126,9 @@ export function notify(title, message) {
   return Promise.resolve(false);
 }
 
+// Only ever a post on x.com (see sources.js): never a file, an app or another scheme from a feed.
 export function openUrl(url) {
+  if (!isPostUrl(url)) return Promise.resolve(false);
   const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'explorer' : 'xdg-open';
   return run(cmd, [url]);
 }

package/src/sources.js

@@ -9,6 +9,53 @@ export class RateLimited extends Error {
   }
 }
 
+// Network limits: a slow, stuck or huge response can't stall the watcher or fill memory.
+const TIMEOUT_MS = 30_000;
+const MAX_BYTES = 2 * 1024 * 1024;
+
+async function get(url, headers = {}) {
+  return fetch(url, { headers: { 'User-Agent': UA, ...headers }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+}
+
+async function readText(res) {
+  if (!res.body) return '';
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.length;
+    if (size > MAX_BYTES) {
+      await reader.cancel();
+      throw new Error('response too large');
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+// Post text ends up in the terminal, notifications and the widget: no control characters (NULs, ANSI
+// and OSC escapes), only text.
+export const clean = (s) => String(s ?? '').replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '');
+
+const STATUS = /\/status(?:es)?\/(\d{5,25})(?:\D|$)/;
+
+// The only links tibodog ever opens or hands to the widget: a post on x.com, rebuilt from its id.
+// A feed's own <link> could point anywhere (file://, a custom app scheme, a local app).
+export function postUrl(username, id) {
+  return /^\d{5,25}$/.test(String(id)) ? `https://x.com/${username || 'i'}/status/${id}` : null;
+}
+
+export function isPostUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.protocol === 'https:' && /^(www\.|mobile\.)?(x|twitter)\.com$/.test(u.hostname) && STATUS.test(u.pathname);
+  } catch {
+    return false;
+  }
+}
+
 // --- X API v2 (needs a bearer token; timeline reads require a paid tier) ---
 
 export function xSource({ username, bearerToken, missingTokenMessage }) {
@@ -16,15 +63,14 @@ export function xSource({ username, bearerToken, missingTokenMessage }) {
   let userId = null;
 
   async function api(path) {
-    const res = await fetch(`https://api.x.com/2${path}`, {
-      headers: { Authorization: `Bearer ${bearerToken}`, 'User-Agent': UA },
-    });
+    const res = await get(`https://api.x.com/2${path}`, { Authorization: `Bearer ${bearerToken}` });
     if (res.status === 429) {
       const reset = Number(res.headers.get('x-rate-limit-reset'));
       throw new RateLimited(reset ? reset * 1000 : Date.now() + 15 * 60_000);
     }
-    if (!res.ok) throw new Error(`X API ${res.status}: ${(await res.text()).slice(0, 200)}`);
-    return res.json();
+    const body = await readText(res);
+    if (!res.ok) throw new Error(`X API ${res.status}: ${clean(body).slice(0, 200)}`);
+    return JSON.parse(body);
   }
 
   return {
@@ -39,9 +85,9 @@ export function xSource({ username, bearerToken, missingTokenMessage }) {
         `/users/${userId}/tweets?max_results=10&exclude=retweets&tweet.fields=created_at,note_tweet`,
       );
       return data.map((t) => ({
-        id: t.id,
-        text: t.note_tweet?.text ?? t.text,
-        url: `https://x.com/${username}/status/${t.id}`,
+        id: String(t.id),
+        text: clean(t.note_tweet?.text ?? t.text).trim(),
+        url: postUrl(username, t.id),
         createdAt: t.created_at,
       }));
     },
@@ -49,48 +95,111 @@ export function xSource({ username, bearerToken, missingTokenMessage }) {
 }
 
 // --- RSS / Atom (Nitter, RSSHub, rss.app, ... anything that mirrors the account) ---
+// Scanned with indexOf rather than regexes over the whole body, so a malformed or hostile feed stays
+// linear time.
+
+const MAX_ITEMS = 50;
+const ENTITIES = { lt: '<', gt: '>', quot: '"', apos: "'", amp: '&', nbsp: ' ' };
 
-const decode = (s) =>
-  s
-    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
-    .replace(/<[^>]+>/g, ' ')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;|&apos;/g, "'")
-    .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
-    .replace(/&amp;/g, '&')
-    .replace(/\s+/g, ' ')
-    .trim();
-
-const tag = (xml, name) => {
-  const m = xml.match(new RegExp(`<${name}[^>]*>([\\s\\S]*?)</${name}>`, 'i'));
-  return m ? m[1] : '';
+function unwrapCdata(s) {
+  let out = '';
+  let i = 0;
+  for (;;) {
+    const start = s.indexOf('<![CDATA[', i);
+    if (start === -1) return out + s.slice(i);
+    const end = s.indexOf(']]>', start + 9);
+    if (end === -1) return out + s.slice(i, start) + s.slice(start + 9);
+    out += s.slice(i, start) + s.slice(start + 9, end);
+    i = end + 3;
+  }
+}
+
+const stripTags = (s) => s.replace(/<[^<>]*>/g, ' ');
+
+const entities = (s) =>
+  s.replace(/&(#x[0-9a-f]{1,8}|#\d{1,10}|lt|gt|quot|apos|amp|nbsp);/gi, (_, e) => {
+    const name = e.toLowerCase();
+    if (name[0] !== '#') return ENTITIES[name];
+    const n = name[1] === 'x' ? parseInt(name.slice(2), 16) : Number(name.slice(1));
+    return n > 0 && n <= 0x10ffff && (n < 0xd800 || n > 0xdfff) ? String.fromCodePoint(n) : '';
+  });
+
+// Escaped HTML in descriptions (&lt;p&gt;) only becomes tags after decoding, so strip twice.
+const decode = (s) => clean(stripTags(entities(stripTags(unwrapCdata(s))))).replace(/\s+/g, ' ').trim();
+
+// The first <name ...>...</name> (or a self-closing <name .../>) in xml.
+function element(xml, name) {
+  const lower = xml.toLowerCase();
+  let i = 0;
+  while ((i = lower.indexOf(`<${name}`, i)) !== -1) {
+    const next = lower[i + name.length + 1];
+    if (next === '>' || next === '/' || /\s/.test(next ?? '')) {
+      const headEnd = lower.indexOf('>', i);
+      if (headEnd === -1) return null;
+      const head = xml.slice(i, headEnd + 1);
+      if (lower[headEnd - 1] === '/') return { head, inner: '' };
+      const close = lower.indexOf(`</${name}`, headEnd);
+      if (close === -1) return null;
+      return { head, inner: xml.slice(headEnd + 1, close) };
+    }
+    i += name.length + 1;
+  }
+  return null;
+}
+
+const text = (xml, ...names) => {
+  for (const n of names) {
+    const el = element(xml, n);
+    if (el && el.inner.trim()) return decode(el.inner);
+  }
+  return '';
 };
 
-export function parseFeed(xml) {
-  const blocks = xml.match(/<(item|entry)[\s>][\s\S]*?<\/\1>/gi) ?? [];
-  return blocks.map((b) => {
-    const link = decode(tag(b, 'link')) || (b.match(/<link[^>]*href="([^"]+)"/i)?.[1] ?? '');
-    const title = decode(tag(b, 'title'));
-    const body = decode(tag(b, 'description') || tag(b, 'content') || tag(b, 'summary'));
+function items(xml) {
+  const lower = xml.toLowerCase();
+  const out = [];
+  let i = 0;
+  while (out.length < MAX_ITEMS) {
+    const a = lower.indexOf('<item', i);
+    const b = lower.indexOf('<entry', i);
+    const start = a === -1 ? b : b === -1 ? a : Math.min(a, b);
+    if (start === -1) break;
+    const tagName = start === a ? 'item' : 'entry';
+    const end = lower.indexOf(`</${tagName}>`, start);
+    if (end === -1) break;
+    out.push(xml.slice(start, end));
+    i = end + tagName.length + 3;
+  }
+  return out;
+}
+
+export function parseFeed(xml, username) {
+  return items(xml).map((b) => {
+    const linkEl = element(b, 'link');
+    const href = linkEl?.head.match(/href\s*=\s*"([^"]*)"/i)?.[1] ?? '';
+    const link = (linkEl && decode(linkEl.inner)) || decode(href);
+    const guid = text(b, 'guid', 'id');
+    const title = text(b, 'title');
+    const body = text(b, 'description', 'content', 'summary');
+    // Mirrors link to themselves (nitter.net/<user>/status/<id>); the status id is what's shared.
+    const sid = link.match(STATUS)?.[1] ?? guid.match(STATUS)?.[1] ?? (/^\d{5,25}$/.test(guid) ? guid : null);
     return {
-      id: decode(tag(b, 'guid') || tag(b, 'id')) || link,
+      id: sid ?? (guid || link),
       text: body.length > title.length ? body : title,
-      url: link,
-      createdAt: decode(tag(b, 'pubDate') || tag(b, 'published') || tag(b, 'updated')),
+      url: postUrl(username, sid),
+      createdAt: text(b, 'pubDate', 'published', 'updated'),
     };
   });
 }
 
-export function rssSource({ url }) {
+export function rssSource({ url, username }) {
   return {
     name: `RSS ${new URL(url).host}`,
     async fetch() {
-      const res = await fetch(url, { headers: { 'User-Agent': UA } });
+      const res = await get(url);
       if (res.status === 429) throw new RateLimited(Date.now() + 5 * 60_000);
       if (!res.ok) throw new Error(`RSS ${res.status}`);
-      return parseFeed(await res.text());
+      return parseFeed(await readText(res), username);
     },
   };
 }