@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/app.js

@@ -0,0 +1,444 @@
+/** Assemblage du serveur local : services, garde, routes de l'API, fichiers de l'interface. */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { auditInput, cancelInput, cwdInput, decisionInput, newConversationInput, pairInput, phoneToggleInput, previewInput, runInput, scopeInput, sendInput, settingsPatch } from '../shared/schemas.js';
+import { PC_ONLY_SETTINGS } from '../shared/types.js';
+import { Audits } from './audits/registry.js';
+import { Brain } from './brain/brain.js';
+import { ConversationStore, listTuiSessions } from './brain/conversations.js';
+import { OllamaProvider } from './brain/ollama.js';
+import { VERSION, defaultSettings } from './config.js';
+import { PowerShellAnalyzer } from './engine/analyzer.js';
+import { Engine } from './engine/engine.js';
+import { PowerShellRunner, engineEnv, probePowerShell } from './engine/runner.js';
+import { AppError, forbidden, notFound } from './errors.js';
+import { PAIR_PATH, checkRemoteRequest, checkRequest } from './http/guard.js';
+import { Router, pipeEvents, sendJson } from './http/router.js';
+import { SECURITY_HEADERS, serveStatic } from './http/static.js';
+import { Journal } from './journal.js';
+import { Fiches, parseCardRequest } from './search/fiche.js';
+import { PlacesService, parsePlacesRequest } from './search/lieux.js';
+import { Overpass } from './search/overpass.js';
+import { Searxng } from './search/searxng.js';
+import { TileCache, parseTile } from './search/tiles.js';
+import { TUI_JOURNAL } from './lien.js';
+import { StatusService, catalogItems } from './status.js';
+import { ScopeStore, SettingsStore } from './stores.js';
+import { Savoir } from './savoir/base.js';
+import { ReadError, fetchPage, readPage } from './savoir/lecture.js';
+import { PhoneAccess, cookieValue, setCookie } from './telephone/acces.js';
+const JOURNAL_KINDS = ['command', 'refusal', 'audit', 'ai', 'search', 'scope', 'settings', 'security', 'system'];
+const JOURNAL_OUTCOMES = ['ok', 'error', 'refused', 'cancelled', 'info'];
+const pick = (value, allowed) => allowed.includes(value ?? '') ? value : undefined;
+export async function createApp(options) {
+    const { config } = options;
+    const persist = options.persist !== false;
+    const data = (name) => (persist ? path.join(config.dataDir, name) : null);
+    if (persist)
+        fs.mkdirSync(config.dataDir, { recursive: true });
+    const env = engineEnv(process.env);
+    /**
+     * Requête arrivée par l'écoute du téléphone : son appareil (null pendant l'appairage). Suit la requête à travers les appels
+     * asynchrones, jusqu'aux entrées du journal qu'elle provoque, marquées « via : telephone ».
+     */
+    const fromPhone = new AsyncLocalStorage();
+    const phoneDevice = () => fromPhone.getStore()?.device ?? null;
+    // Le journal de la TUI est lu, jamais écrit : le tableau de bord montre l'activité des deux interfaces.
+    const journal = new Journal(data('journal.jsonl'), {
+        extra: persist ? [path.join(config.tuiDir, TUI_JOURNAL)] : [],
+        tag: () => {
+            const store = fromPhone.getStore();
+            return store ? { via: 'telephone', ...(store.device ? { appareil: store.device.name } : {}) } : null;
+        },
+    });
+    const settings = new SettingsStore(data('reglages.json'), defaultSettings(config));
+    const scope = new ScopeStore(data('perimetre.json'));
+    const probe = options.probe ?? (await probePowerShell(env));
+    const analyzer = options.analyzer ?? new PowerShellAnalyzer({ env, cwd: persist ? config.dataDir : config.home });
+    const runner = options.runner ?? new PowerShellRunner({ env, oemTable: probe.oemTable });
+    const engine = new Engine({ analyzer, runner, journal, settings: () => settings.get(), targets: () => scope.list(), probe, home: config.home, systemRoot: config.systemRoot });
+    let cached = null;
+    const provider = () => {
+        if (options.provider)
+            return options.provider;
+        const url = settings.get().ollama.baseUrl;
+        if (!cached || cached.url !== url)
+            cached = { url, provider: new OllamaProvider(url) };
+        return cached.provider;
+    };
+    let searxng = null;
+    // Sans persistance (tests) et sans remplaçant, aucune recherche ne sort : même le SearXNG local n'est pas appelé
+    const offlineSearch = {
+        web: () => Promise.reject(new Error('recherche coupée pendant les tests')),
+        place: () => Promise.reject(new Error('recherche coupée pendant les tests')),
+        images: () => Promise.reject(new Error('recherche coupée pendant les tests')),
+        health: () => Promise.resolve({ available: false, latencyMs: null, error: 'Recherche coupée pendant les tests.' }),
+    };
+    const search = () => {
+        if (options.search)
+            return options.search;
+        if (!persist)
+            return offlineSearch;
+        const url = settings.get().search.url;
+        if (!searxng || searxng.url !== url)
+            searxng = { url, backend: new Searxng(() => url) };
+        return searxng.backend;
+    };
+    const offline = () => Promise.reject(new Error('réseau coupé pendant les tests'));
+    const tiles = new TileCache(data('tuiles'), options.tileFetch ?? (persist ? fetch : offline));
+    const placesBackend = options.places ?? new Overpass(persist ? fetch : offline);
+    const places = new PlacesService(() => placesBackend, data('lieux'));
+    const fiches = new Fiches({
+        search,
+        places: () => placesBackend,
+        fetcher: options.cardFetch ?? (persist ? fetch : offline),
+        onLookup: (request, card) => journal.add({
+            kind: 'search',
+            outcome: card.note && !card.description && !card.image ? 'error' : 'ok',
+            title: `Fiche du lieu : ${request.name.slice(0, 100)}`,
+            detail: card.description ? `description : ${card.descriptionSource?.label ?? '?'}${card.image ? ', image' : ''}` : (card.note ?? 'rien trouvé'),
+            data: { query: `${request.name} ${request.zone}`.trim(), osm: request.osm, origin: 'console' },
+        }),
+    });
+    const conversations = new ConversationStore(data('conversations'));
+    // Le savoir local : sans persistance, une base en mémoire ; les pages ne sortent sur le réseau qu'avec un vrai serveur
+    const savoir = new Savoir(data('savoir.db'));
+    const pageFetch = options.pageFetch ?? (persist ? fetchPage : () => Promise.reject(new ReadError('Lecture coupée pendant les tests.')));
+    const brain = new Brain({
+        provider,
+        engine,
+        journal,
+        settings: () => settings.get(),
+        store: conversations,
+        search,
+        prefetchPlaces: (category, where) => places.prefetch(category, where),
+        savoir,
+        readPage: (url, signal) => readPage(url, signal, pageFetch),
+    });
+    const audits = new Audits({ engine, journal, settings: () => settings.get(), targets: () => scope.list(), home: config.home, dir: data('audits') });
+    const token = options.token ?? randomBytes(24).toString('hex');
+    const phone = new PhoneAccess({
+        dir: data('telephone'),
+        port: config.phonePort,
+        ...(config.phoneAddresses ? { addresses: () => config.phoneAddresses ?? [] } : {}),
+        journal,
+        serve: (req, res) => serveRemote(req, res),
+    });
+    const startedAt = new Date().toISOString();
+    const rejections = { count: 0, last: null, reason: null, logged: 0 };
+    const status = new StatusService({
+        config,
+        startedAt,
+        journal,
+        audits,
+        brain,
+        engine,
+        probe,
+        provider,
+        search,
+        settings: () => settings.get(),
+        targets: () => scope.list(),
+        guardRejections: () => ({ count: rejections.count, last: rejections.last, reason: rejections.reason }),
+        phone: () => phone.summary(),
+    });
+    const router = new Router();
+    // ------------------------------------------------------------ Session et état
+    router.add('GET', '/api/session', (ctx) => {
+        const device = phoneDevice();
+        if (!device)
+            return ctx.json({ token, version: VERSION, dev: config.dev });
+        // Chaque visite repousse l'échéance du cookie de 30 jours.
+        const value = cookieValue(ctx.req.headers.cookie);
+        if (value)
+            ctx.res.setHeader('Set-Cookie', setCookie(value));
+        ctx.json({ token, version: VERSION, dev: config.dev, remote: true, device: device.name });
+    });
+    router.add('GET', '/api/status', async (ctx) => ctx.json(await status.snapshot()));
+    // ------------------------------------------------------------ Réglages, liste blanche, périmètre
+    router.add('GET', '/api/settings', (ctx) => ctx.json(settings.get()));
+    router.add('PUT', '/api/settings', async (ctx) => {
+        const patch = await ctx.body(settingsPatch);
+        if (fromPhone.getStore()) {
+            const groups = patch;
+            const touched = PC_ONLY_SETTINGS.filter((key) => {
+                if (!key.includes('.'))
+                    return groups[key] !== undefined;
+                const [group = '', field = ''] = key.split('.');
+                const g = groups[group];
+                return typeof g === 'object' && g !== null && g[field] !== undefined;
+            });
+            if (touched.length > 0)
+                throw new AppError('pc_only', 403, 'Se règle sur le PC : depuis le téléphone, la politique ne peut pas être élargie (liste blanche, dossiers autorisés, langage contraint, confirmation des lectures, mode full cyber, adresses d’Ollama et de SearXNG).');
+        }
+        const next = settings.patch(patch);
+        journal.add({ kind: 'settings', outcome: 'info', title: `Réglages modifiés : ${Object.keys(patch).join(', ') || 'aucun champ'}`, data: { patch } });
+        ctx.json(next);
+    });
+    router.add('GET', '/api/policy', (ctx) => ctx.json({ items: catalogItems(settings.get()) }));
+    router.add('GET', '/api/scope', (ctx) => ctx.json({ targets: scope.list() }));
+    router.add('POST', '/api/scope', async (ctx) => {
+        const input = await ctx.body(scopeInput);
+        const target = scope.add(input);
+        journal.add({ kind: 'scope', outcome: 'info', title: `Cible ajoutée au périmètre : ${target.host}`, detail: 'Attestation : la cible t’appartient ou tu as une autorisation écrite.', data: { host: target.host, includeSubdomains: target.includeSubdomains, note: target.note } });
+        ctx.json(target, 201);
+    });
+    router.add('DELETE', '/api/scope/:id', (ctx) => {
+        const removed = scope.remove(ctx.params.id ?? '');
+        journal.add({ kind: 'scope', outcome: 'info', title: `Cible retirée du périmètre : ${removed.host}`, data: { host: removed.host } });
+        ctx.json({ ok: true });
+    });
+    // ------------------------------------------------------------ Téléphone
+    const pcOnly = () => {
+        if (fromPhone.getStore())
+            throw new AppError('pc_only', 403, 'L’accès téléphone se gère sur le PC, dans Réglages, Téléphone.');
+    };
+    router.add('GET', '/api/telephone', (ctx) => {
+        pcOnly();
+        ctx.json(phone.state());
+    });
+    router.add('PUT', '/api/telephone', async (ctx) => {
+        pcOnly();
+        const { active } = await ctx.body(phoneToggleInput);
+        ctx.json(active ? await phone.open() : await phone.close());
+    });
+    router.add('POST', '/api/telephone/code', (ctx) => {
+        pcOnly();
+        ctx.json(phone.newCode());
+    });
+    router.add('DELETE', '/api/telephone/appareils/:id', (ctx) => {
+        pcOnly();
+        ctx.json(phone.removeDevice(ctx.params.id ?? ''));
+    });
+    router.add('POST', PAIR_PATH, async (ctx) => {
+        // Sur le PC, il n'y a rien à appairer : la route n'existe que par l'écoute du téléphone.
+        if (!fromPhone.getStore())
+            throw notFound('Adresse inconnue de l’API.');
+        const { code } = await ctx.body(pairInput);
+        const { device, cookie } = phone.pair(code, String(ctx.req.headers['user-agent'] ?? ''));
+        ctx.res.setHeader('Set-Cookie', setCookie(cookie));
+        ctx.json({ name: device.name });
+    });
+    // ------------------------------------------------------------ Moteur d'exécution
+    router.add('POST', '/api/engine/preview', async (ctx) => {
+        const input = await ctx.body(previewInput);
+        ctx.json(await engine.preview(input.command, input.cwd, 'terminal'));
+    });
+    router.add('POST', '/api/engine/run', async (ctx) => {
+        const input = await ctx.body(runInput);
+        const execution = engine.start(input.ticket, { acknowledge: input.acknowledge, confirmation: input.confirmation });
+        await pipeEvents(ctx, execution.events);
+    });
+    router.add('POST', '/api/engine/cancel', async (ctx) => {
+        const input = await ctx.body(cancelInput);
+        ctx.json({ cancelled: engine.cancel(input.execId) });
+    });
+    router.add('POST', '/api/engine/cwd', async (ctx) => {
+        const input = await ctx.body(cwdInput);
+        ctx.json({ cwd: engine.resolveCwd(input.from, input.to) });
+    });
+    router.add('GET', '/api/engine/cwd', (ctx) => ctx.json({ cwd: engine.available ? engine.resolveCwd(engine.defaultCwd(), '.') : engine.defaultCwd() }));
+    // ------------------------------------------------------------ Journal
+    router.add('GET', '/api/journal', (ctx) => {
+        const q = ctx.url.searchParams;
+        ctx.json({
+            entries: journal.query({
+                kind: pick(q.get('kind'), JOURNAL_KINDS),
+                outcome: pick(q.get('outcome'), JOURNAL_OUTCOMES),
+                ...(q.get('q') ? { q: q.get('q') ?? '' } : {}),
+                limit: Number(q.get('limit')) || 100,
+                ...(q.get('before') ? { before: q.get('before') ?? '' } : {}),
+            }),
+            total: journal.size,
+        });
+    });
+    router.add('GET', '/api/journal/export', (ctx) => ctx.text(journal.exportText(), 'application/x-ndjson', 'promethee-journal.jsonl'));
+    // ------------------------------------------------------------ Cerveau
+    router.add('GET', '/api/models', async (ctx) => ctx.json(await brain.models()));
+    router.add('GET', '/api/brain/conversations', (ctx) => ctx.json({ conversations: conversations.list() }));
+    router.add('POST', '/api/brain/conversations', async (ctx) => {
+        const input = await ctx.body(newConversationInput);
+        ctx.json(conversations.create(input.model ?? settings.get().model ?? ''), 201);
+    });
+    router.add('GET', '/api/brain/conversations/:id', (ctx) => ctx.json(conversations.get(ctx.params.id ?? '')));
+    router.add('DELETE', '/api/brain/conversations/:id', (ctx) => {
+        brain.stop(ctx.params.id ?? '');
+        conversations.remove(ctx.params.id ?? '');
+        ctx.json({ ok: true });
+    });
+    router.add('POST', '/api/brain/conversations/:id/send', async (ctx) => {
+        const input = await ctx.body(sendInput);
+        await pipeEvents(ctx, await brain.send(ctx.params.id ?? '', input.text, input.attachments ?? []));
+    });
+    router.add('POST', '/api/brain/conversations/:id/decision', async (ctx) => {
+        const input = await ctx.body(decisionInput);
+        await pipeEvents(ctx, await brain.decide(ctx.params.id ?? '', input.proposalId, input.decision, input.acknowledge));
+    });
+    // ------------------------------------------------------------ Carte des recherches
+    const mapAllowed = () => {
+        if (!settings.get().search.enabled)
+            throw forbidden('La recherche web est coupée dans les réglages, la carte aussi.', 'search_disabled');
+    };
+    /** Abandonné si la page ferme la connexion avant la réponse. */
+    const untilClosed = (res) => {
+        const controller = new AbortController();
+        res.on('close', () => {
+            if (!res.writableFinished)
+                controller.abort();
+        });
+        return controller.signal;
+    };
+    router.add('GET', '/api/map/places', async (ctx) => {
+        mapAllowed();
+        const { category, where } = parsePlacesRequest(ctx.url.searchParams.get('category'), ctx.url.searchParams.get('where'));
+        ctx.json(await places.get(category, where));
+    });
+    router.add('GET', '/api/map/card', async (ctx) => {
+        mapAllowed();
+        ctx.json({ card: await fiches.card(parseCardRequest(ctx.url.searchParams), untilClosed(ctx.res)) });
+    });
+    router.add('GET', '/api/map/image/:id', async (ctx) => {
+        mapAllowed();
+        const { bytes, type } = await fiches.image(ctx.params.id ?? '', untilClosed(ctx.res));
+        ctx.res.writeHead(200, { 'Content-Type': type, 'Content-Length': bytes.length, 'Cache-Control': 'private, max-age=86400', 'X-Content-Type-Options': 'nosniff' });
+        ctx.res.end(bytes);
+    });
+    router.add('GET', '/api/map/tile/:z/:x/:y', async (ctx) => {
+        mapAllowed();
+        const { z, x, y } = parseTile(ctx.params.z ?? '', ctx.params.x ?? '', ctx.params.y ?? '');
+        const png = await tiles.get(z, x, y);
+        ctx.res.writeHead(200, { 'Content-Type': 'image/png', 'Content-Length': png.length, 'Cache-Control': 'private, max-age=86400' });
+        ctx.res.end(png);
+    });
+    // ------------------------------------------------------------ Savoir local
+    router.add('GET', '/api/savoir', (ctx) => {
+        const limit = Number(ctx.url.searchParams.get('limit') ?? 100);
+        ctx.json(savoir.list({ q: (ctx.url.searchParams.get('q') ?? '').slice(0, 200), limit: Number.isFinite(limit) ? limit : 100 }));
+    });
+    router.add('GET', '/api/savoir/:id', (ctx) => {
+        const found = savoir.get(ctx.params.id ?? '');
+        if (!found)
+            throw notFound('Cette page n’est plus dans le savoir.');
+        ctx.json(found);
+    });
+    router.add('DELETE', '/api/savoir/:id', (ctx) => {
+        const page = savoir.forget(ctx.params.id ?? '');
+        if (!page)
+            throw notFound('Cette page n’est plus dans le savoir.');
+        journal.add({ kind: 'search', outcome: 'info', title: `Savoir : page oubliée, ${page.title.slice(0, 100)}`, detail: page.url, data: { url: page.url, origin: 'console' } });
+        ctx.json({ ok: true });
+    });
+    router.add('DELETE', '/api/savoir', (ctx) => {
+        const removed = savoir.forgetAll();
+        journal.add({ kind: 'search', outcome: 'info', title: 'Savoir vidé', detail: `${removed} page${removed > 1 ? 's' : ''} oubliée${removed > 1 ? 's' : ''}.`, data: { removed, origin: 'console' } });
+        ctx.json({ removed });
+    });
+    router.add('POST', '/api/brain/conversations/:id/stop', (ctx) => ctx.json({ stopped: brain.stop(ctx.params.id ?? '') }));
+    router.add('GET', '/api/tui/sessions', (ctx) => ctx.json({ sessions: listTuiSessions(config.tuiDir) }));
+    // ------------------------------------------------------------ Audits
+    router.add('GET', '/api/audits/modules', (ctx) => ctx.json({ modules: audits.modules() }));
+    router.add('POST', '/api/audits/run', async (ctx) => {
+        const input = await ctx.body(auditInput);
+        const events = audits.run(input.module, input.input);
+        // Le premier pas vérifie l'entrée et le périmètre : une erreur ici part en réponse HTTP normale.
+        const first = await events.next();
+        await pipeEvents(ctx, (async function* () {
+            if (!first.done)
+                yield first.value;
+            yield* events;
+        })());
+    });
+    router.add('GET', '/api/audits/history', (ctx) => ctx.json({ runs: audits.history({ module: ctx.url.searchParams.get('module') ?? undefined }) }));
+    router.add('GET', '/api/audits/findings', (ctx) => ctx.json({ runs: audits.latest() }));
+    router.add('GET', '/api/audits/:id', (ctx) => ctx.json(audits.get(ctx.params.id ?? '')));
+    router.add('GET', '/api/audits/:id/report', (ctx) => ctx.text(audits.report(ctx.params.id ?? ''), 'text/markdown', `promethee-audit-${ctx.params.id}.md`));
+    router.add('DELETE', '/api/audits/:id', (ctx) => {
+        audits.remove(ctx.params.id ?? '');
+        ctx.json({ ok: true });
+    });
+    const parseUrl = (req, res) => {
+        try {
+            return new URL(req.url ?? '/', 'http://localhost');
+        }
+        catch {
+            sendJson(res, { error: { code: 'bad_request', message: 'Adresse invalide.' } }, 400);
+            return null;
+        }
+    };
+    const reject = (req, res, url, verdict) => {
+        // Un téléphone pas encore appairé demande la session : c'est le chemin normal de l'appairage, pas une attaque.
+        if (verdict.code !== 'not_paired') {
+            rejections.count++;
+            rejections.last = new Date().toISOString();
+            rejections.reason = verdict.message;
+            // Une entrée de journal toutes les 30 secondes au plus, pour qu'une rafale ne le remplisse pas.
+            if (Date.now() - rejections.logged > 30_000) {
+                rejections.logged = Date.now();
+                journal.add({ kind: 'security', outcome: 'refused', title: `Requête refusée par la garde : ${verdict.message}`, detail: `${req.method ?? '?'} ${url.pathname}`, data: { code: verdict.code, host: req.headers.host ?? null, origin: req.headers.origin ?? null } });
+            }
+        }
+        sendJson(res, { error: { code: verdict.code, message: verdict.message } }, verdict.status);
+    };
+    const dispatch = async (req, res, url) => {
+        if (url.pathname.startsWith('/api/')) {
+            for (const [name, value] of Object.entries(SECURITY_HEADERS))
+                if (name !== 'Content-Security-Policy')
+                    res.setHeader(name, value);
+            const handled = await router.handle(req, res, url);
+            if (!handled)
+                sendJson(res, { error: { code: 'not_found', message: 'Adresse inconnue de l’API.' } }, 404);
+            return;
+        }
+        serveStatic(res, config.distDir, url.pathname, req.method ?? 'GET');
+    };
+    const server = http.createServer((req, res) => {
+        // Le port réellement écouté fait foi (utile quand le système en choisit un libre).
+        const address = server.address();
+        const guard = { port: address && typeof address === 'object' ? address.port : config.port, dev: config.dev, token };
+        void (async () => {
+            const url = parseUrl(req, res);
+            if (!url)
+                return;
+            const verdict = checkRequest(req, url.pathname, guard);
+            if (!verdict.ok)
+                return reject(req, res, url, verdict);
+            await dispatch(req, res, url);
+        })();
+    });
+    /** Requête arrivée par l'écoute du téléphone (server/telephone/acces.ts). */
+    const serveRemote = (req, res) => {
+        void (async () => {
+            const url = parseUrl(req, res);
+            if (!url)
+                return;
+            const verdict = checkRemoteRequest(req, url.pathname, { hosts: phone.hosts(), token, device: (cookie) => phone.device(cookie, req.socket) });
+            if (!verdict.ok)
+                return reject(req, res, url, verdict);
+            await fromPhone.run({ device: verdict.device }, () => dispatch(req, res, url));
+        })();
+    };
+    journal.add({ kind: 'system', outcome: 'info', title: `Serveur Prométhée ${VERSION} démarré`, detail: probe.available ? `PowerShell ${probe.version ?? '?'} · page de codes ${probe.codePage ?? '?'}` : `Moteur indisponible : ${probe.error ?? ''}` });
+    return {
+        server,
+        token,
+        engine,
+        journal,
+        settings,
+        scope,
+        audits,
+        brain,
+        phone,
+        close: async () => {
+            await phone.dispose();
+            await new Promise((resolve) => {
+                engine.cancelAll();
+                analyzer.dispose();
+                server.close(() => resolve());
+                server.closeAllConnections();
+            });
+            savoir.close();
+        },
+    };
+}