Checkpoint peering identity and opt-in discovery

server.js

@@ -20,6 +20,8 @@ const { hosterLinks } = require('./greatest/hosters');
 const { secret } = require('./runtime/config');
 const { PeeringState, requirePeer } = require('./peering/state');
 const peerClient = require('./peering/client');
+const { DiscoveryStore } = require('./discovery/store');
+const { generate: generateDiscovery } = require('./discovery/engine');
 const {
   applyPulse, applyVisit, chapterInsight, eligiblePages, emptyRecord, libraryInsight, mangaInsight, publicSummary,
 } = require('./reading-analytics');
@@ -36,6 +38,9 @@ const SCRAPER_TOKEN = secret('SCRAPER_TOKEN');
 const SENTINEL_URL = String(process.env.SENTINEL_URL || 'http://127.0.0.1:8092').replace(/\/$/, '');
 const PEER_DATA = path.resolve(process.env.PEER_DATA || path.join(DATA, 'peering'));
 const peerStore = new PeeringState(PEER_DATA);
+const discoveryStore = new DiscoveryStore(DATA);
+const DISCOVERY_CACHE = path.join(DATA, 'scraper', 'metadata', 'anilist');
+let discoveryRun = null, discoveryError = null;
 const PUB = path.join(__dirname, 'public');
 const IMG = /\.(jpe?g|png|webp|gif|avif|bmp)$/i;
 const MIME = {
@@ -50,7 +55,7 @@ const catalog = new Catalog(DATA);
 const greatestCatalog = loadGreatestCatalog();
 const greatestById = new Map(greatestCatalog.entries.map(entry => [entry.id, entry]));
 const DB_FILE = path.join(DATA, 'db.json'), CACHE_FILE = path.join(DATA, 'scan-cache.json'), INDEX_FILE = path.join(DATA, 'library-index.json');
-const db = { users: {}, sessions: {}, progress: {}, reading: {}, follows: {}, notes: {}, votes: {}, greatestRatings: {}, known: {} };
+const db = { users: {}, sessions: {}, progress: {}, reading: {}, follows: {}, notes: {}, votes: {}, greatestRatings: {}, discoveryFeedback: {}, known: {} };
 // A corrupt db.json stops the server instead of silently starting empty and overwriting it.
 if (fs.existsSync(DB_FILE)) Object.assign(db, JSON.parse(fs.readFileSync(DB_FILE, 'utf8')));
 function writeAtomic(file, text) { fs.writeFileSync(file + '.tmp', text); fs.renameSync(file + '.tmp', file); }
@@ -78,7 +83,8 @@ function checkPw(pw, stored) {
   return want.length === got.length && crypto.timingSafeEqual(want, got);
 }
 const DUMMY_HASH = hashPw('x');
-const DEFAULTS = { startMode: 'last', lastMode: 'page', adapt: true, skipExtras: false, skipCovers: false, flowPageGap: true, pageTone: 'original', readingClock: false, readingStory: true, zoom: {}, webhook: '' };
+const DEFAULTS = { startMode: 'last', lastMode: 'page', adapt: true, skipExtras: false, skipCovers: false, flowPageGap: true, pageTone: 'original', readingClock: false, readingStory: true,
+  discoveryEnabled: false, discoveryReadingActivity: false, discoveryMature: false, zoom: {}, webhook: '' };
 const settingsOf = u => ({ ...DEFAULTS, ...u.settings, zoom: { ...(u.settings && u.settings.zoom) } });
 
 function createUser(name, pw, admin, replace) {
@@ -217,6 +223,35 @@ async function scraperRequest(endpoint, body) {
   return data;
 }
 
+function readDiscovery() {
+  try { return discoveryStore.load(); }
+  catch (error) { bad(503, error.message); }
+}
+function startDiscoveryRun() {
+  if (discoveryRun?.status === 'running') bad(409, 'A discovery run is already active');
+  readDiscovery(); // Refuse a new run if the on-disk store is corrupt.
+  const id = crypto.randomUUID(), startedAt = new Date().toISOString();
+  discoveryRun = { id, status: 'running', startedAt };
+  discoveryError = null;
+  setImmediate(async () => {
+    try {
+      let queuedTitles = [], queueAvailable = true;
+      try { queuedTitles = (await scraperRequest('/api/state')).queue?.filter(item => !['complete', 'removed'].includes(item.status)).map(item => item.title) || []; }
+      catch { queueAvailable = false; }
+      const result = generateDiscovery({ db, library: lib.mangas, greatest: greatestCatalog,
+        cacheDir: DISCOVERY_CACHE, queuedTitles });
+      const published = discoveryStore.publish({ ...result, startedAt });
+      discoveryRun = { id, status: 'success', startedAt, finishedAt: published.lastRun.finishedAt,
+        candidates: published.lastRun.candidateCount, queueAvailable };
+    } catch (error) {
+      discoveryError = String(error.message || error).slice(0, 300);
+      discoveryRun = { id, status: 'failed', startedAt, finishedAt: new Date().toISOString() };
+      console.error('[discovery]', discoveryError);
+    }
+  });
+  return discoveryRun;
+}
+
 const mangaDexSearchCache = new Map();
 let lastMangaDexSearch = 0;
 async function searchGreatestMangaDex(entry) {
@@ -364,7 +399,8 @@ const routes = {
     if (['last', 'flow', 'page', 'book'].includes(b.startMode)) s.startMode = b.startMode;
     if (['flow', 'page', 'book'].includes(b.lastMode)) s.lastMode = b.lastMode;
     if (['original', 'inverted', 'sepia', 'dim', 'extra-dim'].includes(b.pageTone)) s.pageTone = b.pageTone;
-    for (const k of ['adapt', 'skipExtras', 'skipCovers', 'flowPageGap', 'readingClock', 'readingStory']) if (typeof b[k] === 'boolean') s[k] = b[k];
+    for (const k of ['adapt', 'skipExtras', 'skipCovers', 'flowPageGap', 'readingClock', 'readingStory',
+      'discoveryEnabled', 'discoveryReadingActivity', 'discoveryMature']) if (typeof b[k] === 'boolean') s[k] = b[k];
     if (b.zoom && typeof b.zoom === 'object') {
       s.zoom = {};
       for (const k of ['flow', 'page', 'book', 'strip']) if (+b.zoom[k] > 0) s.zoom[k] = Math.min(8, Math.max(0.1, +b.zoom[k]));
@@ -404,6 +440,35 @@ const routes = {
     };
   },
 
+  'GET /api/discovery': ({ u }) => {
+    const state = readDiscovery(), enabled = !!settingsOf(u).discoveryEnabled;
+    const feed = enabled ? state.feeds[u.name] || null : null;
+    return { enabled, settings: { discoveryEnabled: enabled,
+      discoveryReadingActivity: !!settingsOf(u).discoveryReadingActivity,
+      discoveryMature: !!settingsOf(u).discoveryMature },
+    generatedAt: feed?.generatedAt || null, revision: state.revision, lastRun: state.lastRun,
+    feedback: db.discoveryFeedback?.[u.name] || {},
+    items: (feed?.items || []).map(item => ({ ...item, candidate: state.candidates[item.candidateId] || null })).filter(item => item.candidate) };
+  },
+  'POST /api/discovery/feedback': ({ u, b }) => {
+    if (!settingsOf(u).discoveryEnabled) bad(403, 'Enable personalized discovery first');
+    const id = String(b.candidateId || ''), value = b.value === null ? null : String(b.value || '');
+    if (!readDiscovery().candidates[id]) bad(404, 'Discovery candidate not found');
+    if (value !== null && !['interested', 'maybe', 'dismissed', 'hidden'].includes(value)) bad(400, 'Unknown feedback');
+    const mine = (db.discoveryFeedback ||= {})[u.name] ||= {};
+    if (value === null) delete mine[id]; else mine[id] = value;
+    save();
+    return { candidateId: id, value };
+  },
+  'GET /api/admin/discovery': ({ u }) => {
+    admin(u);
+    const state = readDiscovery();
+    return { revision: state.revision, lastRun: state.lastRun, currentRun: discoveryRun,
+      lastError: discoveryError, optedInUsers: Object.values(db.users).filter(user => user.settings?.discoveryEnabled).length,
+      candidateCount: Object.keys(state.candidates).length };
+  },
+  'POST /api/admin/discovery/run': ({ u }) => { admin(u); return startDiscoveryRun(); },
+
   'GET /api/greatest': ({ u }) => ({
     title: greatestCatalog.title, updatedAt: greatestCatalog.updatedAt, periods: greatestCatalog.periods,
     ratings: GREATEST_RATINGS,
@@ -634,6 +699,7 @@ const routes = {
     const name = String(b.name || '');
     if (name === u.name) bad(400, "You can't delete your own account.");
     delete db.users[name]; delete db.progress[name]; delete db.reading[name]; delete db.follows[name]; delete db.notes[name];
+    if (db.discoveryFeedback) delete db.discoveryFeedback[name];
     if (db.greatestRatings) delete db.greatestRatings[name];
     for (const [k, s] of Object.entries(db.sessions)) if (s.u === name) delete db.sessions[k];
     save();
@@ -709,7 +775,7 @@ const routes = {
     const remote = await peerRemote(() => peerClient.manga(peerStore, id, shareId));
     const present = await peerRemote(() => peerClient.catalog(peerStore, id));
     if (!present.some(entry => entry.id === shareId)) bad(404, 'Peer manga not available');
-    return scraperRequest('/api/queue', { url: `peer://${id}/${shareId}`, title: remote.title,
+    return scraperRequest('/api/queue', { url: `peer://${id}/${shareId}`, title: remote.title, workIdentity: remote.workIdentity,
       scope: b.scope || { mode: 'missing' }, existingPolicy: b.existingPolicy || 'skip-any',
       ...(b.libraryMangaId ? { libraryMangaId: String(b.libraryMangaId) } : {}) });
   },
@@ -727,7 +793,7 @@ const routes = {
       if (!available.has(mangaId)) { results.push({ id: mangaId, status: 'unavailable' }); continue; }
       try {
         const remote = await peerRemote(() => peerClient.manga(peerStore, id, mangaId));
-        const result = await scraperRequest('/api/queue', { url: `peer://${id}/${mangaId}`, title: remote.title,
+        const result = await scraperRequest('/api/queue', { url: `peer://${id}/${mangaId}`, title: remote.title, workIdentity: remote.workIdentity,
           scope: { mode: 'missing' }, existingPolicy: 'skip-any' });
         results.push({ id: mangaId, title: remote.title, status: 'queued', result });
       } catch (error) { results.push({ id: mangaId, status: 'failed', error: String(error.message || error).slice(0, 240) }); }