@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/search/overpass.js

@@ -0,0 +1,216 @@
+import { VERSION } from '../config.js';
+import { AppError } from '../errors.js';
+import { cut } from './searxng.js';
+/**
+ * Deux instances publiques, dans l'ordre. Mesuré le 15/11/2026 aux heures chargées : la principale répondait 502 « at
+ * capacity » ou en 38 s, celle de VK en 17 s, pour les hôtels de Paris (757 Ko). La seconde part si la première échoue
+ * ou n'a pas répondu au bout de HEDGE_MS. La première réponse gagne, l'autre est abandonnée.
+ */
+export const OVERPASS_URLS = ['https://overpass-api.de/api/interpreter', 'https://maps.mail.ru/osm/tools/overpass/api/interpreter'];
+/** Points rendus au plus. total dit combien il y en a en tout. */
+export const MAX_POINTS = 2000;
+const TIMEOUT_MS = 45_000;
+const HEDGE_MS = 8_000;
+/**
+ * Quand toutes les instances refusent (429, 502, 503, 504), on réessaie après 3 s, puis 6 s, 12 s, tant que le tout
+ * tient en une minute, comme le demande Overpass. Mesuré le 15/11/2026 : VK répondait 504 en 0,5 s pendant que la
+ * principale refusait par moments, et répondait en 33 s à d'autres.
+ */
+const RETRY_MS = 3_000;
+const BUDGET_MS = 60_000;
+/** Attend `ms`, ou rejette dès que `signal` est arrêté. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new DOMException('Opération interrompue.', 'AbortError'));
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', stop);
+            resolve();
+        }, ms);
+        const stop = () => {
+            clearTimeout(timer);
+            reject(new DOMException('Opération interrompue.', 'AbortError'));
+        };
+        signal.addEventListener('abort', stop, { once: true });
+    });
+}
+const clean = (s) => (typeof s === 'string' ? s.replace(/\s+/g, ' ').trim() : '');
+const coord = (n) => n.toFixed(7);
+/** La requête Overpass : le nombre de lieux nommés de la catégorie dans la zone, puis leurs noms, centres et étiquettes. */
+export function overpassQuery(filter, zone) {
+    let scope = '';
+    let clause;
+    if (zone.kind === 'area') {
+        scope = `area(${zone.id})->.zone;`;
+        clause = '(area.zone)';
+    }
+    else if (zone.kind === 'bbox') {
+        const [south, north, west, east] = zone.bbox;
+        clause = `(${coord(south)},${coord(west)},${coord(north)},${coord(east)})`;
+    }
+    else
+        clause = `(around:${Math.round(zone.radius)},${coord(zone.lat)},${coord(zone.lon)})`;
+    return `[out:json][timeout:20];${scope}nwr${filter}["name"]${clause}->.lieux;.lieux out count;.lieux out tags center ${MAX_POINTS};`;
+}
+/** L'adresse d'après les étiquettes addr:* : « 12 Rue de Tolbiac, 75013 Paris », ou null. */
+export function addressOf(tags) {
+    const street = [clean(tags['addr:housenumber']), clean(tags['addr:street'])].filter(Boolean).join(' ');
+    const city = [clean(tags['addr:postcode']), clean(tags['addr:city'])].filter(Boolean).join(' ');
+    const out = [street, city].filter(Boolean).join(', ');
+    return out ? cut(out, 160) : null;
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+/** Les lieux d'une réponse Overpass : nommés, avec des coordonnées, dans l'ordre d'Overpass. */
+export function toPoints(body) {
+    const elements = Array.isArray(body?.elements) ? body.elements : [];
+    let total = 0;
+    const points = [];
+    for (const e of elements) {
+        const tags = (e?.tags ?? {});
+        if (e?.type === 'count') {
+            total = Number(tags.total) || 0;
+            continue;
+        }
+        if (!['node', 'way', 'relation'].includes(String(e?.type)) || typeof e.id !== 'number')
+            continue;
+        const center = (e.type === 'node' ? e : (e.center ?? {}));
+        const lat = num(center.lat);
+        const lon = num(center.lon);
+        const name = clean(tags.name);
+        if (lat === null || lon === null || Math.abs(lat) > 90 || Math.abs(lon) > 180 || !name)
+            continue;
+        points.push({ name: cut(name, 120), lat, lon, address: addressOf(tags), osm: `${String(e.type)}/${e.id}` });
+    }
+    return { total: Math.max(total, points.length), points };
+}
+export class Overpass {
+    fetcher;
+    urls;
+    hedgeMs;
+    retryMs;
+    budgetMs;
+    constructor(fetcher = fetch, urls = OVERPASS_URLS, hedgeMs = HEDGE_MS, retryMs = RETRY_MS, budgetMs = BUDGET_MS) {
+        this.fetcher = fetcher;
+        this.urls = urls;
+        this.hedgeMs = hedgeMs;
+        this.retryMs = retryMs;
+        this.budgetMs = budgetMs;
+    }
+    /** Des tours sur les instances, avec une attente qui double entre deux tours refusés, dans le budget d'une minute. */
+    async run(query, signal) {
+        const started = Date.now();
+        let wait = this.retryMs;
+        for (;;) {
+            try {
+                return await this.round(query, signal);
+            }
+            catch (err) {
+                const busy = err instanceof AppError && err.code === 'map_busy';
+                if (signal.aborted || !busy || Date.now() - started + wait > this.budgetMs)
+                    throw err;
+                await sleep(wait, signal);
+                wait *= 2;
+            }
+        }
+    }
+    /** Un tour : les instances l'une après l'autre, ou ensemble passé HEDGE_MS. La première réponse lisible gagne. */
+    round(query, signal) {
+        return new Promise((resolve, reject) => {
+            const controllers = [];
+            let next = 0;
+            let running = 0;
+            let settled = false;
+            let lastError = null;
+            let timer;
+            const finish = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                for (const c of controllers)
+                    c.abort();
+                signal.removeEventListener('abort', onAbort);
+                fn();
+            };
+            const onAbort = () => finish(() => reject(signal.reason instanceof Error ? signal.reason : new DOMException('Opération interrompue.', 'AbortError')));
+            const start = () => {
+                const url = this.urls[next++];
+                if (url === undefined)
+                    return false;
+                const controller = new AbortController();
+                controllers.push(controller);
+                running++;
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    if (!settled)
+                        start();
+                }, this.hedgeMs);
+                this.once(url, query, controller.signal).then((body) => finish(() => resolve(body)), (err) => {
+                    running--;
+                    if (settled)
+                        return;
+                    lastError = err;
+                    if (!start() && running === 0)
+                        finish(() => reject(lastError));
+                });
+                return true;
+            };
+            if (signal.aborted)
+                return onAbort();
+            signal.addEventListener('abort', onAbort, { once: true });
+            start();
+        });
+    }
+    async once(url, query, signal) {
+        let res;
+        try {
+            res = await this.fetcher(url, {
+                method: 'POST',
+                body: new URLSearchParams({ data: query }).toString(),
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json', 'User-Agent': `Promethee/${VERSION} (console locale, carte des recherches)` },
+                signal: AbortSignal.any([signal, AbortSignal.timeout(TIMEOUT_MS)]),
+            });
+        }
+        catch (err) {
+            if (signal.aborted)
+                throw err;
+            if (err instanceof Error && err.name === 'TimeoutError')
+                throw new AppError('map_timeout', 504, `OpenStreetMap (Overpass) n’a pas répondu en ${TIMEOUT_MS / 1000} s.`);
+            throw new AppError('map_unreachable', 502, 'OpenStreetMap (Overpass) ne répond pas. Vérifie la connexion à internet.');
+        }
+        if ([429, 502, 503, 504].includes(res.status))
+            throw new AppError('map_busy', 503, 'OpenStreetMap (Overpass) est occupé. Réessaie dans une minute.');
+        if (!res.ok)
+            throw new AppError('map_error', 502, `OpenStreetMap (Overpass) a répondu ${res.status}.`);
+        let body;
+        try {
+            body = (await res.json());
+        }
+        catch {
+            throw new AppError('map_error', 502, 'OpenStreetMap (Overpass) a renvoyé une réponse illisible.');
+        }
+        // Overpass répond 200 avec une remarque quand la requête dépasse son temps ou sa mémoire
+        if (typeof body.remark === 'string' && /error|timed out/i.test(body.remark))
+            throw new AppError('map_error', 502, 'OpenStreetMap (Overpass) n’a pas pu finir la recherche. Essaie une zone plus petite.');
+        return body;
+    }
+    async many(filter, zone, signal) {
+        const found = toPoints(await this.run(overpassQuery(filter, zone), signal));
+        // Une relation sans zone calculée par Overpass (un site, un quartier récent) ne rend rien : sa boîte prend le relais
+        if (found.total === 0 && zone.kind === 'area' && zone.bbox)
+            return toPoints(await this.run(overpassQuery(filter, { kind: 'bbox', bbox: zone.bbox }), signal));
+        return found;
+    }
+    async tags(osm, signal) {
+        const m = /^(node|way|relation)\/(\d{1,12})$/.exec(osm);
+        if (!m)
+            return null;
+        const body = await this.run(`[out:json][timeout:10];${m[1]}(${m[2]});out tags;`, signal);
+        const elements = Array.isArray(body.elements) ? body.elements : [];
+        const first = elements.find((e) => e?.type === m[1]);
+        const tags = first?.tags;
+        if (!tags || typeof tags !== 'object')
+            return null;
+        return Object.fromEntries(Object.entries(tags).filter((e) => typeof e[1] === 'string'));
+    }
+}

package/lib/server/search/searxng.js

@@ -0,0 +1,223 @@
+import { AppError } from '../errors.js';
+export const SEARCH_TIMEOUT_MS = 12_000;
+export const MAX_SOURCES = 6;
+const MAX_SNIPPET = 280;
+/** Même règle que le schéma des réglages : l'adresse de SearXNG reste sur cette machine. */
+export const isLoopbackUrl = (url) => /^http:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d{1,5})?\/?$/i.test(url);
+const clean = (s) => (typeof s === 'string' ? s.replace(/\s+/g, ' ').trim() : '');
+/** Coupe sans casser un mot (sauf un mot seul plus long que la limite). */
+export function cut(text, max) {
+    if (text.length <= max)
+        return text;
+    const head = text.slice(0, max);
+    const space = text[max] === ' ' ? max : head.lastIndexOf(' ');
+    return `${(space > 0 ? head.slice(0, space) : head).replace(/[\s,.;:]+$/, '')}…`;
+}
+/** Les sources d'une recherche générale : adresses http(s) seulement, sans doublon, dans l'ordre de SearXNG. */
+export function toSources(results) {
+    if (!Array.isArray(results))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const r of results) {
+        const url = clean(r?.url);
+        const title = clean(r?.title);
+        if (!/^https?:\/\/[^\s]+$/i.test(url) || !title || seen.has(url))
+            continue;
+        seen.add(url);
+        const engines = Array.isArray(r.engines) ? r.engines.filter((e) => typeof e === 'string') : [];
+        out.push({
+            n: out.length + 1,
+            title: cut(title, 160),
+            url,
+            snippet: cut(clean(r.content), MAX_SNIPPET),
+            engines,
+            publishedDate: typeof r.publishedDate === 'string' && r.publishedDate ? r.publishedDate : null,
+        });
+        if (out.length >= MAX_SOURCES)
+            break;
+    }
+    return out;
+}
+const STOP = new Set(['de', 'du', 'des', 'la', 'le', 'les', 'l', 'd', 'a', 'au', 'aux', 'en', 'et', 'un', 'une', 'the', 'of']);
+/** Mots significatifs d'un nom de lieu, sans accents ni majuscules. */
+export function placeWords(name) {
+    return name
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= 3 && !STOP.has(w));
+}
+/** Mots qui disent ce qu'on veut savoir d'un lieu (son adresse, sa carte, le chemin), pas le lieu lui-même. */
+const PLACE_NOISE = new Set(['adresse', 'carte', 'plan', 'itineraire', 'localisation', 'emplacement', 'coordonnees', 'gps', 'trouver', 'situe', 'ou', 'acces']);
+const plain = (word) => word
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9']/g, '');
+/**
+ * Ce qu'on cherche sur la carte, dans l'ordre : la requête sans ses mots de service, puis le lieu du classificateur.
+ * Le lieu se réduit souvent à la ville (« Amiens, France » pour la gare d'Amiens), la requête garde l'endroit.
+ */
+export function placeCandidates(query, place) {
+    const fromQuery = query
+        .split(/\s+/)
+        .filter((w) => w && !PLACE_NOISE.has(plain(w)))
+        .join(' ');
+    const seen = new Set();
+    return [fromQuery, place.trim()].filter((q) => {
+        const key = q.split(/\s+/).map(plain).join(' ');
+        if (!q || seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function formatAddress(address, name) {
+    if (!address || typeof address !== 'object')
+        return null;
+    const a = address;
+    const street = [clean(a.house_number), clean(a.road)].filter(Boolean).join(' ');
+    const city = [clean(a.postcode), clean(a.locality)].filter(Boolean).join(' ');
+    const parts = [street, city, clean(a.country)].filter((p) => p && p !== name);
+    return parts.length > 0 ? parts.join(', ') : null;
+}
+/** Un nombre fini, ou null. Une chaîne vide ou blanche n'est pas 0. */
+const num = (v) => {
+    const n = typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' ? Number(v) : Number.NaN;
+    return Number.isFinite(n) ? n : null;
+};
+/** Plus de la moitié des mots voulus (placeWords) se trouvent dans le texte. Sans mot voulu, rien ne passe. */
+export function hasMajority(wanted, text) {
+    if (wanted.length === 0)
+        return false;
+    const own = new Set(placeWords(text));
+    return wanted.filter((w) => own.has(w)).length * 2 > wanted.length;
+}
+/** Les images d'une recherche : vignettes en https ou en data:image, sans doublon, dans l'ordre de SearXNG. */
+export function toImages(results) {
+    if (!Array.isArray(results))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const r of results) {
+        const thumbnail = clean(r?.thumbnail_src) || clean(r?.thumbnail) || clean(r?.img_src);
+        const url = clean(r?.url);
+        if (!/^(https:\/\/|data:image\/)/i.test(thumbnail) || !/^https?:\/\/[^\s]+$/i.test(url) || seen.has(thumbnail))
+            continue;
+        seen.add(thumbnail);
+        const engines = Array.isArray(r.engines) ? r.engines.filter((e) => typeof e === 'string') : typeof r.engine === 'string' ? [r.engine] : [];
+        out.push({ thumbnail, url, title: cut(clean(r.title), 160), engines });
+        if (out.length >= 40)
+            break;
+    }
+    return out;
+}
+/**
+ * Le lieu à montrer : le premier résultat avec des coordonnées dont le nom et l'adresse contiennent PLUS de la moitié
+ * des mots du lieu demandé (la partie avant la virgule). Sinon, pas de carte : « ANSSI, Paris » ne doit montrer ni une
+ * assurance (« Assurances ANSSUR ») ni le « Boulevard de Paris ».
+ */
+export function toPlace(results, wanted) {
+    if (!Array.isArray(results))
+        return null;
+    const words = placeWords(wanted.split(',')[0] ?? wanted);
+    for (const r of results) {
+        const lat = num(r?.latitude);
+        const lon = num(r?.longitude);
+        const name = clean(r?.title);
+        if (lat === null || lon === null || Math.abs(lat) > 90 || Math.abs(lon) > 180 || !name)
+            continue;
+        const address = (r.address ?? {});
+        if (words.length > 0 && !hasMajority(words, `${name} ${clean(address.name)} ${clean(address.locality)}`))
+            continue;
+        const box = Array.isArray(r.boundingbox) ? r.boundingbox.map(num) : [];
+        const bbox = box.length === 4 && box.every((v) => v !== null) ? box : null;
+        const url = clean(r.url);
+        const osm = (r.osm ?? {});
+        const osmId = ['node', 'way', 'relation'].includes(String(osm.type)) && /^\d{1,12}$/.test(String(osm.id)) ? `${String(osm.type)}/${String(osm.id)}` : null;
+        return {
+            name: cut(name, 120),
+            address: formatAddress(r.address, name),
+            lat,
+            lon,
+            bbox,
+            osmUrl: /^https:\/\/(www\.)?openstreetmap\.org\//.test(url) ? url : osmLink(lat, lon),
+            osm: osmId,
+            city: clean(address.locality) || null,
+        };
+    }
+    return null;
+}
+export const osmLink = (lat, lon) => `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}#map=16/${lat}/${lon}`;
+export class Searxng {
+    url;
+    fetcher;
+    constructor(url, fetcher = fetch) {
+        this.url = url;
+        this.fetcher = fetcher;
+    }
+    base() {
+        const url = this.url().replace(/\/+$/, '');
+        if (!isLoopbackUrl(url))
+            throw new AppError('search_url', 400, 'L’adresse de SearXNG doit rester sur cette machine (127.0.0.1).');
+        return url;
+    }
+    async get(params, signal) {
+        const base = this.base();
+        const query = new URLSearchParams({ format: 'json', language: 'fr', safesearch: '1', ...params });
+        let res;
+        try {
+            res = await this.fetcher(`${base}/search?${query}`, { signal: AbortSignal.any([signal, AbortSignal.timeout(SEARCH_TIMEOUT_MS)]), headers: { Accept: 'application/json' } });
+        }
+        catch (err) {
+            if (signal.aborted)
+                throw err;
+            if (err instanceof Error && err.name === 'TimeoutError')
+                throw new AppError('search_timeout', 504, `SearXNG n’a pas répondu en ${SEARCH_TIMEOUT_MS / 1000} s.`);
+            throw new AppError('search_unreachable', 502, `SearXNG ne répond pas sur ${base}. Lance « npm run searxng » pour le démarrer.`);
+        }
+        if (res.status === 403)
+            throw new AppError('search_format', 502, 'SearXNG refuse le format JSON : ajoute json à search.formats dans son settings.yml.');
+        if (!res.ok)
+            throw new AppError('search_error', 502, `SearXNG a répondu ${res.status}.`);
+        try {
+            return (await res.json());
+        }
+        catch {
+            throw new AppError('search_error', 502, 'SearXNG a renvoyé une réponse illisible.');
+        }
+    }
+    async web(query, signal) {
+        const body = await this.get({ q: query }, signal);
+        return toSources(body.results);
+    }
+    async place(name, signal) {
+        const body = await this.get({ q: name, categories: 'map' }, signal);
+        return toPlace(body.results, name);
+    }
+    async images(query, signal) {
+        const body = await this.get({ q: query, categories: 'images' }, signal);
+        return toImages(body.results);
+    }
+    async health() {
+        const started = performance.now();
+        let base;
+        try {
+            base = this.base();
+        }
+        catch (err) {
+            return { available: false, latencyMs: null, error: err.message };
+        }
+        try {
+            const res = await this.fetcher(`${base}/healthz`, { signal: AbortSignal.timeout(2000) });
+            if (!res.ok)
+                return { available: false, latencyMs: null, error: `SearXNG a répondu ${res.status}.` };
+            return { available: true, latencyMs: Math.round(performance.now() - started), error: null };
+        }
+        catch {
+            return { available: false, latencyMs: null, error: `SearXNG ne répond pas sur ${base}. Lance « npm run searxng ».` };
+        }
+    }
+}

package/lib/server/search/tiles.js

@@ -0,0 +1,103 @@
+/**
+ * Tuiles de carte d'OpenStreetMap, servies par le serveur local.
+ *
+ * La CSP de la console n'autorise que ses propres images : le serveur va chercher la tuile, la garde sept jours
+ * sur le disque et la renvoie. Règles d'usage d'OSM respectées : User-Agent qui nomme l'application, deux
+ * connexions au plus, cache local. https://operations.osmfoundation.org/policies/tiles/
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { VERSION } from '../config.js';
+import { AppError, badRequest } from '../errors.js';
+export const TILE_URL = 'https://tile.openstreetmap.org';
+export const MAX_ZOOM = 19;
+const KEEP_MS = 7 * 86_400_000;
+const MAX_PARALLEL = 2;
+const MAX_TILE_BYTES = 512 * 1024;
+/** z, x, y entiers et dans la grille du niveau de zoom. */
+export function parseTile(z, x, y) {
+    const ok = (s) => /^\d{1,7}$/.test(s);
+    if (!ok(z) || !ok(x) || !ok(y.replace(/\.png$/, '')))
+        throw badRequest('Tuile invalide.');
+    const t = { z: Number(z), x: Number(x), y: Number(y.replace(/\.png$/, '')) };
+    const size = 2 ** t.z;
+    if (t.z > MAX_ZOOM || t.x >= size || t.y >= size)
+        throw badRequest('Tuile hors de la carte.');
+    return t;
+}
+export class TileCache {
+    dir;
+    fetcher;
+    memory = new Map();
+    pending = new Map();
+    active = 0;
+    queue = [];
+    /** dir null : cache en mémoire seulement (tests). */
+    constructor(dir, fetcher = fetch) {
+        this.dir = dir;
+        this.fetcher = fetcher;
+    }
+    file(z, x, y) {
+        return this.dir ? path.join(this.dir, String(z), String(x), `${y}.png`) : null;
+    }
+    cached(key, file, fresh) {
+        if (!file)
+            return this.memory.get(key) ?? null;
+        const stat = fs.statSync(file, { throwIfNoEntry: false });
+        if (!stat || (fresh && Date.now() - stat.mtimeMs > KEEP_MS))
+            return null;
+        return fs.readFileSync(file);
+    }
+    async slot(work) {
+        if (this.active >= MAX_PARALLEL)
+            await new Promise((resolve) => this.queue.push(resolve));
+        this.active++;
+        try {
+            return await work();
+        }
+        finally {
+            this.active--;
+            this.queue.shift()?.();
+        }
+    }
+    async get(z, x, y) {
+        const key = `${z}/${x}/${y}`;
+        const file = this.file(z, x, y);
+        const fresh = this.cached(key, file, true);
+        if (fresh)
+            return fresh;
+        const running = this.pending.get(key);
+        if (running)
+            return running;
+        const work = this.slot(() => this.download(key, file)).finally(() => this.pending.delete(key));
+        this.pending.set(key, work);
+        return work;
+    }
+    async download(key, file) {
+        let body;
+        try {
+            const res = await this.fetcher(`${TILE_URL}/${key}.png`, { headers: { 'User-Agent': `Promethee/${VERSION} (console locale, carte des recherches)` }, signal: AbortSignal.timeout(10_000) });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            body = Buffer.from(await res.arrayBuffer());
+            if (body.length === 0 || body.length > MAX_TILE_BYTES)
+                throw new Error('taille inattendue');
+        }
+        catch {
+            // Hors ligne : une tuile ancienne vaut mieux qu'un trou dans la carte
+            const stale = this.cached(key, file, false);
+            if (stale)
+                return stale;
+            throw new AppError('tile_unreachable', 502, 'Impossible de charger la carte depuis OpenStreetMap.');
+        }
+        if (file) {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            const tmp = `${file}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, body);
+            fs.renameSync(tmp, file);
+        }
+        else
+            this.memory.set(key, body);
+        return body;
+    }
+}