@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/http/guard.js

@@ -0,0 +1,75 @@
+/**
+ * Garde de l'API locale.
+ *
+ * Un serveur qui exécute des commandes ne doit répondre qu'à sa propre interface. Trois contrôles :
+ *  - Host : seuls 127.0.0.1 et localhost sur le bon port (bloque le « DNS rebinding ») ;
+ *  - Origin : si le navigateur l'envoie, ce doit être l'interface elle-même (bloque les autres sites) ;
+ *  - jeton de session : exigé sur toute l'API, sauf la route qui le délivre à l'interface.
+ */
+import { timingSafeEqual } from 'node:crypto';
+const DEV_PORT = 5173;
+export function allowedHosts(options) {
+    const ports = options.dev ? [options.port, DEV_PORT] : [options.port];
+    return ports.flatMap((port) => [`127.0.0.1:${port}`, `localhost:${port}`]);
+}
+function sameToken(given, expected) {
+    const a = Buffer.from(given);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+export function checkRequest(req, pathname, options) {
+    const hosts = allowedHosts(options);
+    const host = (req.headers.host ?? '').toLowerCase();
+    if (!hosts.includes(host))
+        return { ok: false, status: 421, code: 'bad_host', message: 'Hôte non autorisé.' };
+    const origin = req.headers.origin;
+    if (origin !== undefined && !hosts.some((h) => origin.toLowerCase() === `http://${h}`))
+        return { ok: false, status: 403, code: 'bad_origin', message: 'Origine non autorisée.' };
+    if (!pathname.startsWith('/api/'))
+        return { ok: true };
+    const site = req.headers['sec-fetch-site'];
+    if (site === 'cross-site')
+        return { ok: false, status: 403, code: 'cross_site', message: 'Requête venant d’un autre site refusée.' };
+    if (pathname === '/api/session') {
+        if (req.method !== 'GET')
+            return { ok: false, status: 405, code: 'method_not_allowed', message: 'Méthode non autorisée.' };
+        if (site !== undefined && site !== 'same-origin' && site !== 'none')
+            return { ok: false, status: 403, code: 'cross_site', message: 'Requête venant d’un autre site refusée.' };
+        return { ok: true };
+    }
+    const token = req.headers['x-promethee-token'];
+    if (typeof token !== 'string' || !sameToken(token, options.token))
+        return { ok: false, status: 401, code: 'bad_token', message: 'Jeton de session absent ou invalide. Recharge la page.' };
+    return { ok: true };
+}
+export const PAIR_PATH = '/api/telephone/appairer';
+export function checkRemoteRequest(req, pathname, options) {
+    const host = (req.headers.host ?? '').toLowerCase();
+    if (!options.hosts.includes(host))
+        return { ok: false, status: 421, code: 'bad_host', message: 'Hôte non autorisé.' };
+    const origin = req.headers.origin;
+    if (origin !== undefined && origin.toLowerCase() !== `https://${host}`)
+        return { ok: false, status: 403, code: 'bad_origin', message: 'Origine non autorisée.' };
+    if (!pathname.startsWith('/api/'))
+        return { ok: true, device: null };
+    const site = req.headers['sec-fetch-site'];
+    if (site !== undefined && site !== 'same-origin' && site !== 'none')
+        return { ok: false, status: 403, code: 'cross_site', message: 'Requête venant d’un autre site refusée.' };
+    if (pathname === PAIR_PATH) {
+        if (req.method !== 'POST')
+            return { ok: false, status: 405, code: 'method_not_allowed', message: 'Méthode non autorisée.' };
+        return { ok: true, device: null };
+    }
+    const device = options.device(req.headers.cookie);
+    if (device === null)
+        return { ok: false, status: 401, code: 'not_paired', message: 'Ce téléphone n’est pas appairé. Sur le PC, ouvre Réglages, Téléphone, puis scanne le QR code ou tape le code affiché.' };
+    if (pathname === '/api/session') {
+        if (req.method !== 'GET')
+            return { ok: false, status: 405, code: 'method_not_allowed', message: 'Méthode non autorisée.' };
+        return { ok: true, device };
+    }
+    const token = req.headers['x-promethee-token'];
+    if (typeof token !== 'string' || !sameToken(token, options.token))
+        return { ok: false, status: 401, code: 'bad_token', message: 'Jeton de session absent ou invalide. Recharge la page.' };
+    return { ok: true, device };
+}

package/lib/server/http/router.js

@@ -0,0 +1,154 @@
+import { AppError, badRequest, describeError } from '../errors.js';
+const MAX_BODY = 256 * 1024;
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buf = chunk;
+        size += buf.length;
+        if (size > MAX_BODY)
+            throw new AppError('too_large', 413, 'Requête trop volumineuse.');
+        chunks.push(buf);
+    }
+    if (size === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw badRequest('Le corps de la requête n’est pas du JSON valide.');
+    }
+}
+export function sendJson(res, data, status = 200) {
+    if (res.headersSent)
+        return;
+    const body = JSON.stringify(data);
+    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(body), 'Cache-Control': 'no-store' });
+    res.end(body);
+}
+export function sendError(res, err) {
+    const { code, message, status } = describeError(err);
+    if (res.headersSent) {
+        // Flux déjà commencé : l'erreur part comme dernier événement.
+        res.write(`${JSON.stringify({ type: 'error', code, message })}\n`);
+        res.end();
+        return;
+    }
+    sendJson(res, { error: { code, message } }, status === 499 ? 400 : status);
+}
+export class Router {
+    routes = [];
+    add(method, pattern, handler) {
+        this.routes.push({ method, parts: pattern.split('/').filter(Boolean), handler });
+    }
+    match(method, pathname) {
+        const parts = pathname.split('/').filter(Boolean);
+        let pathMatched = false;
+        for (const route of this.routes) {
+            if (route.parts.length !== parts.length)
+                continue;
+            const params = {};
+            let ok = true;
+            for (let i = 0; i < parts.length; i++) {
+                const expected = route.parts[i] ?? '';
+                const actual = parts[i] ?? '';
+                if (expected.startsWith(':')) {
+                    try {
+                        params[expected.slice(1)] = decodeURIComponent(actual);
+                    }
+                    catch {
+                        ok = false;
+                    }
+                }
+                else if (expected !== actual)
+                    ok = false;
+                if (!ok)
+                    break;
+            }
+            if (!ok)
+                continue;
+            pathMatched = true;
+            if (route.method === method)
+                return { handler: route.handler, params };
+        }
+        return pathMatched ? 'method' : null;
+    }
+    /** Traite une requête d'API. Renvoie false si aucune route ne correspond. */
+    async handle(req, res, url) {
+        const found = this.match(req.method ?? 'GET', url.pathname);
+        if (found === null)
+            return false;
+        if (found === 'method') {
+            sendJson(res, { error: { code: 'method_not_allowed', message: 'Méthode non autorisée pour cette adresse.' } }, 405);
+            return true;
+        }
+        const ctx = {
+            req,
+            res,
+            url,
+            params: found.params,
+            body: async (schema) => {
+                const parsed = schema.safeParse(await readBody(req));
+                if (!parsed.success) {
+                    const issue = parsed.error.issues[0];
+                    throw badRequest(issue ? `${issue.path.join('.') || 'requête'} : ${issue.message}` : 'Requête invalide.', 'invalid_input');
+                }
+                return parsed.data;
+            },
+            json: (data, status) => sendJson(res, data, status),
+            text: (body, contentType, filename) => {
+                res.writeHead(200, {
+                    'Content-Type': `${contentType}; charset=utf-8`,
+                    'Cache-Control': 'no-store',
+                    ...(filename ? { 'Content-Disposition': `attachment; filename="${filename.replace(/[^\w.-]/g, '_')}"` } : {}),
+                });
+                res.end(body);
+            },
+            stream: () => {
+                let closed = false;
+                res.on('close', () => {
+                    closed = true;
+                });
+                res.writeHead(200, { 'Content-Type': 'application/x-ndjson; charset=utf-8', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' });
+                return {
+                    get closed() {
+                        return closed || res.writableEnded;
+                    },
+                    write: (event) => {
+                        if (!closed && !res.writableEnded)
+                            res.write(`${JSON.stringify(event)}\n`);
+                    },
+                    end: () => {
+                        if (!res.writableEnded)
+                            res.end();
+                    },
+                };
+            },
+        };
+        try {
+            await found.handler(ctx);
+        }
+        catch (err) {
+            sendError(res, err);
+        }
+        return true;
+    }
+}
+/** Envoie les événements d'un générateur. Si le client se déconnecte, le générateur est fermé (ce qui annule le travail en cours). */
+export async function pipeEvents(ctx, events) {
+    const stream = ctx.stream();
+    try {
+        for await (const event of events) {
+            if (stream.closed)
+                break;
+            stream.write(event);
+        }
+    }
+    catch (err) {
+        const { code, message } = describeError(err);
+        stream.write({ type: 'error', code, message });
+    }
+    finally {
+        stream.end();
+    }
+}

package/lib/server/http/static.js

@@ -0,0 +1,76 @@
+/** Sert l'interface construite (dossier dist). Aucun fichier en dehors de ce dossier n'est accessible. */
+import fs from 'node:fs';
+import path from 'node:path';
+const TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+    '.json': 'application/json; charset=utf-8',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+    '.txt': 'text/plain; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+};
+export const SECURITY_HEADERS = {
+    'X-Content-Type-Options': 'nosniff',
+    'X-Frame-Options': 'DENY',
+    'Referrer-Policy': 'no-referrer',
+    'Cross-Origin-Opener-Policy': 'same-origin',
+    'Cross-Origin-Resource-Policy': 'same-origin',
+    'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self'; style-src-attr 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'",
+};
+const NOT_BUILT = `<!doctype html><html lang="fr"><meta charset="utf-8"><title>Prométhée</title>
+<body><h1>L’interface n’est pas encore construite</h1>
+<p>Le serveur local tourne, mais le dossier <code>dist</code> est absent. Lance <code>npm run build</code> puis recharge cette page,
+ou utilise <code>npm run dev</code> pendant le développement.</p></body></html>`;
+export function serveStatic(res, distDir, pathname, method) {
+    if (method !== 'GET' && method !== 'HEAD') {
+        res.writeHead(405, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Méthode non autorisée.');
+        return;
+    }
+    let relative;
+    try {
+        relative = decodeURIComponent(pathname);
+    }
+    catch {
+        relative = '/';
+    }
+    const root = path.resolve(distDir);
+    let file = path.resolve(root, `.${relative}`);
+    const inside = file === root || file.startsWith(root + path.sep);
+    if (!inside || relative.includes('\0'))
+        file = path.join(root, 'index.html');
+    let stat = fs.statSync(file, { throwIfNoEntry: false });
+    if (!stat || stat.isDirectory()) {
+        // Fichier demandé avec une extension mais absent : vraie 404. Sinon, on sert l'application.
+        if (path.extname(relative) && relative !== '/index.html') {
+            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Introuvable.');
+            return;
+        }
+        file = path.join(root, 'index.html');
+        stat = fs.statSync(file, { throwIfNoEntry: false });
+    }
+    if (!stat) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', ...SECURITY_HEADERS });
+        res.end(NOT_BUILT);
+        return;
+    }
+    const ext = path.extname(file).toLowerCase();
+    const hashed = /[\\/]assets[\\/]/.test(file);
+    res.writeHead(200, {
+        'Content-Type': TYPES[ext] ?? 'application/octet-stream',
+        'Content-Length': stat.size,
+        'Cache-Control': hashed ? 'public, max-age=31536000, immutable' : 'no-cache',
+        ...SECURITY_HEADERS,
+    });
+    if (method === 'HEAD') {
+        res.end();
+        return;
+    }
+    fs.createReadStream(file).pipe(res);
+}

package/lib/server/index.js

@@ -0,0 +1,40 @@
+/** Point d'entrée : npm start (ou « node server/index.ts »). */
+import { createApp } from './app.js';
+import { VERSION, loadConfig } from './config.js';
+import { writeRendezvous } from './lien.js';
+const config = loadConfig();
+const app = await createApp({ config });
+app.server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE')
+        console.error(`Le port ${config.port} est déjà pris. Ferme l'autre instance de Prométhée, ou change de port avec la variable PROMETHEE_PORT.`);
+    else
+        console.error(`Le serveur n'a pas pu démarrer : ${err.message}`);
+    process.exit(1);
+});
+app.server.listen(config.port, config.host, () => {
+    const url = config.dev ? 'http://127.0.0.1:5173' : `http://${config.host}:${config.port}`;
+    console.log(`\n  Prométhée ${VERSION}`);
+    console.log(`  Console   ${url}`);
+    console.log(`  Écoute    ${config.host}:${config.port} (cette machine)`);
+    console.log(`  Données   ${config.dataDir}`);
+    console.log(`  Moteur    ${app.engine.available ? 'PowerShell prêt' : 'PowerShell indisponible'}`);
+    // La TUI « prmt » lit ce fichier pour partager la liste blanche, le périmètre et le journal.
+    const lien = writeRendezvous(config);
+    console.log(`  TUI prmt  ${lien ? `reliée (${lien})` : 'non reliée : dossier Documents\\Promethee inaccessible'}`);
+    // L'accès téléphone rouvre s'il était ouvert à l'arrêt. Il se ferme dans les Réglages, partie Téléphone.
+    void app.phone.resume().then(() => {
+        const phone = app.phone.state();
+        const ligne = !phone.active ? 'fermé (Réglages, Téléphone, pour l’ouvrir)' : phone.urls.length > 0 ? `${phone.urls.join(', ')} (appareils appairés seulement)` : `ouvert, mais sans écoute : ${phone.error ?? '?'}`;
+        console.log(`  Téléphone ${ligne}\n`);
+    });
+});
+let closing = false;
+const shutdown = () => {
+    if (closing)
+        return;
+    closing = true;
+    void app.close().then(() => process.exit(0));
+    setTimeout(() => process.exit(0), 2000).unref();
+};
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/lib/server/journal.js

@@ -0,0 +1,139 @@
+/**
+ * Journal des actions : des fichiers JSONL en ajout seul.
+ *
+ * La console écrit dans son propre fichier. Elle lit aussi, sans jamais y écrire, le journal que
+ * tient la TUI « prmt » : le tableau de bord montre ainsi l'activité des deux interfaces.
+ */
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const KINDS = new Set(['command', 'refusal', 'audit', 'ai', 'search', 'scope', 'settings', 'security', 'system']);
+const OUTCOMES = new Set(['ok', 'error', 'refused', 'cancelled', 'info']);
+/** Une ligne de journal lisible, ou null si elle est abîmée ou d'un format inconnu. */
+export function parseEntry(line) {
+    if (!line.trim())
+        return null;
+    try {
+        const e = JSON.parse(line);
+        if (typeof e.id !== 'string' || typeof e.at !== 'string' || typeof e.title !== 'string')
+            return null;
+        if (!KINDS.has(String(e.kind)) || !OUTCOMES.has(String(e.outcome)) || Number.isNaN(Date.parse(e.at)))
+            return null;
+        return e;
+    }
+    catch {
+        return null;
+    }
+}
+const sizeOf = (file) => fs.statSync(file, { throwIfNoEntry: false })?.size ?? 0;
+export class Journal {
+    entries = [];
+    file;
+    extra;
+    keep;
+    /** Ajouté aux données de chaque entrée : l'appareil quand la requête vient du téléphone. */
+    tag;
+    /** Taille connue de chaque fichier : s'il a grossi, un autre processus y a écrit. */
+    sizes = new Map();
+    /** file null : journal en mémoire seulement (tests). extra : journaux lus mais jamais écrits. */
+    constructor(file, options = {}) {
+        this.file = file;
+        this.extra = options.extra ?? [];
+        this.keep = options.keep ?? 5000;
+        this.tag = options.tag ?? (() => null);
+        if (file)
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+        this.load();
+    }
+    sources() {
+        return [...(this.file ? [this.file] : []), ...this.extra];
+    }
+    load() {
+        const sources = this.sources();
+        if (sources.length === 0)
+            return;
+        const all = [];
+        for (const source of sources) {
+            this.sizes.set(source, sizeOf(source));
+            let text;
+            try {
+                text = fs.readFileSync(source, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            for (const line of text.split('\n').slice(-this.keep)) {
+                const entry = parseEntry(line);
+                if (entry)
+                    all.push(entry);
+            }
+        }
+        // Le tri est stable : à date égale, l'ordre d'écriture est conservé.
+        all.sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : 0));
+        this.entries = all.slice(-this.keep);
+    }
+    /** Relit les fichiers si l'un d'eux a changé depuis la dernière lecture. */
+    refresh() {
+        for (const source of this.sources()) {
+            if (sizeOf(source) !== (this.sizes.get(source) ?? 0)) {
+                this.load();
+                return;
+            }
+        }
+    }
+    add(entry) {
+        this.refresh();
+        const tag = this.tag();
+        const full = { id: randomBytes(8).toString('hex'), at: new Date().toISOString(), ...entry, ...(tag ? { data: { ...entry.data, ...tag } } : {}) };
+        this.entries.push(full);
+        if (this.entries.length > this.keep)
+            this.entries.splice(0, this.entries.length - this.keep);
+        if (this.file) {
+            try {
+                fs.appendFileSync(this.file, `${JSON.stringify(full)}\n`, 'utf8');
+                this.sizes.set(this.file, sizeOf(this.file));
+            }
+            catch {
+                /* disque plein ou fichier verrouillé : l'entrée reste en mémoire */
+            }
+        }
+        return full;
+    }
+    /** Entrées de la plus récente à la plus ancienne. */
+    query(query = {}) {
+        this.refresh();
+        const limit = Math.min(Math.max(query.limit ?? 100, 1), 500);
+        const needle = query.q?.trim().toLowerCase();
+        const out = [];
+        let passed = query.before === undefined;
+        for (let i = this.entries.length - 1; i >= 0 && out.length < limit; i--) {
+            const e = this.entries[i];
+            if (!e)
+                continue;
+            if (!passed) {
+                if (e.id === query.before)
+                    passed = true;
+                continue;
+            }
+            if (query.kind && e.kind !== query.kind)
+                continue;
+            if (query.outcome && e.outcome !== query.outcome)
+                continue;
+            if (needle && !`${e.title}\n${e.detail ?? ''}`.toLowerCase().includes(needle))
+                continue;
+            out.push(e);
+        }
+        return out;
+    }
+    all() {
+        this.refresh();
+        return this.entries;
+    }
+    get size() {
+        this.refresh();
+        return this.entries.length;
+    }
+    exportText() {
+        return this.all().map((e) => JSON.stringify(e)).join('\n');
+    }
+}

package/lib/server/lien.js

@@ -0,0 +1,33 @@
+/**
+ * Lien avec la TUI « prmt ».
+ *
+ * La console écrit un fichier de rendez-vous dans le dossier de la TUI (Documents\Promethee). La TUI y lit
+ * où trouver Node, le pont de politique et les données communes : les deux interfaces partagent ainsi la
+ * même liste blanche, le même périmètre et un journal que chacune sait lire.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { VERSION } from './config.js';
+import { writeJson } from './stores.js';
+export const TUI_JOURNAL = 'journal.jsonl';
+export const RENDEZVOUS = 'plateforme.json';
+export function rendezvous(config, now = new Date()) {
+    const racine = path.resolve(import.meta.dirname, '..');
+    return { version: VERSION, node: process.execPath, pont: path.join(racine, 'server', 'cli', 'pont.ts'), racine, donnees: config.dataDir, port: config.port, ecritLe: now.toISOString() };
+}
+/** Écrit le fichier de rendez-vous. Renvoie son chemin, ou null si le dossier de la TUI n'est pas accessible. */
+export function writeRendezvous(config) {
+    const file = path.join(config.tuiDir, RENDEZVOUS);
+    try {
+        const next = rendezvous(config);
+        const previous = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+        // Rien à réécrire si seule la date changerait : le fichier ne bouge pas à chaque démarrage.
+        if (previous && Object.keys(next).every((k) => k === 'ecritLe' || previous[k] === next[k]))
+            return file;
+        writeJson(file, next);
+        return file;
+    }
+    catch {
+        return null;
+    }
+}