@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/engine/catalog.js

@@ -0,0 +1,229 @@
+import { hostFromUrl, isSingleHost } from './paths.js';
+const block = (code, message) => ({ code, message, severity: 'block' });
+const warn = (code, message) => ({ code, message, severity: 'warn' });
+const P = ['Path', 'LiteralPath'];
+const cmdlets = new Map();
+const add = (names, rule) => {
+    for (const name of names.trim().split(/\s+/))
+        cmdlets.set(name.toLowerCase(), rule);
+};
+// ------------------------------------------------------------------ Lecture
+add('Get-ChildItem Get-Content Get-Item Get-ItemProperty Get-ItemPropertyValue Get-FileHash Get-Acl Test-Path Resolve-Path Import-Csv', { level: 'read', category: 'fichiers', read: P });
+add('Get-AuthenticodeSignature', { level: 'read', category: 'fichiers', read: ['FilePath', 'LiteralPath'] });
+add('Select-String', { level: 'read', category: 'fichiers', read: P });
+add('Split-Path Join-Path Get-Location Get-PSDrive Get-PSProvider', { level: 'read', category: 'fichiers' });
+add('Get-Process Get-Service Get-ComputerInfo Get-CimInstance Get-WmiObject Get-WinEvent Get-EventLog Get-HotFix Get-Volume Get-Disk Get-Partition Get-ScheduledTask Get-ScheduledTaskInfo Get-LocalUser Get-LocalGroup Get-LocalGroupMember Get-AppxPackage Get-Package Get-PnpDevice Get-Tpm Get-BitLockerVolume Get-WindowsOptionalFeature Get-TimeZone Get-Culture Get-Host Get-ExecutionPolicy Get-Counter Get-History Get-Variable', { level: 'read', category: 'système' });
+add('Get-NetTCPConnection Get-NetUDPEndpoint Get-NetIPAddress Get-NetIPConfiguration Get-NetAdapter Get-NetRoute Get-NetNeighbor Get-NetConnectionProfile Get-NetFirewallProfile Get-NetFirewallRule Get-NetFirewallPortFilter Get-NetFirewallAddressFilter Get-NetIPInterface Get-NetAdapterBinding Get-DnsClient Get-DnsClientServerAddress Get-DnsClientCache Get-SmbShare Get-SmbServerConfiguration Get-SmbConnection', { level: 'read', category: 'réseau' });
+add('Get-MpComputerStatus Get-MpPreference Get-MpThreat Get-MpThreatDetection', { level: 'read', category: 'sécurité' });
+add('Resolve-DnsName', { level: 'read', category: 'réseau', host: ['Name'] });
+add('Test-Connection', { level: 'read', category: 'réseau', host: ['ComputerName'] });
+add('Test-NetConnection', { level: 'read', category: 'réseau', host: ['ComputerName'], scan: ['Port', 'CommonTCPPort'] });
+add('Where-Object ForEach-Object Sort-Object Group-Object Measure-Object Measure-Command', { level: 'read', category: 'pipeline', blocks: true });
+add('Select-Object Format-Table Format-List Format-Wide Format-Custom Out-String Out-Null Out-Host Out-Default ConvertTo-Json ConvertFrom-Json ConvertTo-Csv ConvertFrom-Csv ConvertTo-Html ConvertFrom-StringData Compare-Object Get-Unique Get-Member Get-Random Get-Date Get-Command Get-Help Get-Module Get-Alias New-TimeSpan New-Guid Write-Output Write-Host Write-Warning Write-Error Write-Verbose Write-Information Start-Sleep Clear-Host help', { level: 'read', category: 'pipeline' });
+// ------------------------------------------------------------------ Sensible
+add('New-Item mkdir', { level: 'sensitive', category: 'fichiers', write: ['Path', 'Target', 'Value'], require: ['Path'], note: 'crée un fichier ou un dossier' });
+add('Set-Content Add-Content', { level: 'sensitive', category: 'fichiers', write: P, require: P, note: 'écrit dans un fichier' });
+add('Out-File Tee-Object', { level: 'sensitive', category: 'fichiers', write: ['FilePath', 'LiteralPath'], require: ['FilePath', 'LiteralPath'], note: 'écrit dans un fichier' });
+add('Export-Csv', { level: 'sensitive', category: 'fichiers', write: P, require: P, note: 'écrit un fichier CSV' });
+add('Copy-Item', { level: 'sensitive', category: 'fichiers', read: P, write: ['Destination'], require: ['Destination'], note: 'copie des fichiers' });
+add('Move-Item', { level: 'sensitive', category: 'fichiers', write: [...P, 'Destination'], require: P, note: 'déplace des fichiers' });
+add('Rename-Item', { level: 'sensitive', category: 'fichiers', write: P, require: P, note: 'renomme un élément' });
+add('Compress-Archive Expand-Archive', { level: 'sensitive', category: 'fichiers', read: P, write: ['DestinationPath'], require: ['DestinationPath'], note: 'crée ou extrait une archive' });
+add('Invoke-WebRequest Invoke-RestMethod', { level: 'sensitive', category: 'réseau', host: ['Uri'], write: ['OutFile'], note: 'envoie une requête web' });
+add('Stop-Process', { level: 'sensitive', category: 'processus', note: 'arrête un processus' });
+add('Start-Service Stop-Service Restart-Service', { level: 'sensitive', category: 'système', note: 'agit sur un service' });
+add('Clear-DnsClientCache', { level: 'sensitive', category: 'réseau', note: 'vide le cache DNS' });
+// ------------------------------------------------------------------ Destructif : refusé par défaut, débloquable
+add('Remove-Item Clear-Content', { level: 'destructive', category: 'fichiers', write: P, require: P, note: 'supprime des fichiers ou leur contenu' });
+add('Set-ItemProperty New-ItemProperty Remove-ItemProperty', { level: 'destructive', category: 'système', note: 'modifie le registre ou des propriétés' });
+add('Set-Acl', { level: 'destructive', category: 'fichiers', write: P, require: P, note: 'modifie des permissions' });
+add('Clear-RecycleBin', { level: 'destructive', category: 'fichiers', note: 'vide la corbeille' });
+add('Stop-Computer Restart-Computer', { level: 'destructive', category: 'système', note: 'éteint ou redémarre la machine' });
+add('Set-Service', { level: 'destructive', category: 'système', note: 'reconfigure un service' });
+add('New-NetFirewallRule Remove-NetFirewallRule Set-NetFirewallRule Enable-NetFirewallRule Disable-NetFirewallRule Set-NetFirewallProfile', { level: 'destructive', category: 'réseau', note: 'modifie le pare-feu' });
+add('New-LocalUser Remove-LocalUser Set-LocalUser Add-LocalGroupMember Remove-LocalGroupMember', { level: 'destructive', category: 'système', note: 'modifie les comptes locaux' });
+add('Install-Package Uninstall-Package', { level: 'destructive', category: 'système', note: 'installe ou désinstalle un logiciel' });
+add('Disable-ScheduledTask Enable-ScheduledTask Unregister-ScheduledTask', { level: 'destructive', category: 'système', note: 'modifie une tâche planifiée' });
+add('Start-Process', { level: 'destructive', category: 'processus', note: 'lance un programme quelconque' });
+// ------------------------------------------------------------------ Interdit
+add('Invoke-Expression Invoke-Command Start-Job Add-Type New-Object Import-Module Install-Module Save-Module Invoke-Item Invoke-CimMethod Invoke-WmiMethod Set-CimInstance Remove-CimInstance Register-ObjectEvent Register-WmiEvent Register-CimIndicationEvent Register-ScheduledTask New-PSSession Enter-PSSession New-PSDrive', { level: 'forbidden', category: 'code dynamique', note: 'exécute du code ou une commande que l’analyse ne peut pas voir' });
+add('Set-Alias New-Alias Set-Variable New-Variable Set-Item', { level: 'forbidden', category: 'code dynamique', note: 'peut remplacer une commande autorisée par une autre' });
+add('Set-Location Push-Location Pop-Location', { level: 'forbidden', category: 'dossiers', note: 'change de dossier en cours de commande : utilise « cd » seul dans le terminal' });
+add('Set-ExecutionPolicy Set-MpPreference Add-MpPreference Remove-MpPreference Unblock-File', { level: 'forbidden', category: 'protections', note: 'affaiblit une protection de Windows' });
+add('Format-Volume Clear-Disk Initialize-Disk Remove-Partition', { level: 'forbidden', category: 'disques', note: 'efface un disque ou une partition' });
+// ------------------------------------------------------------------ Applications natives
+const apps = new Map();
+const addApp = (names, rule) => {
+    for (const name of names.trim().split(/\s+/))
+        apps.set(name.toLowerCase(), rule);
+};
+const only = (label, allowed) => (argv) => {
+    const bad = argv.find((a) => !allowed.test(a));
+    return { reasons: bad === undefined ? [] : [block('app-args', `${label} : l’option « ${bad} » n’est pas autorisée (elle modifie la configuration ou n’est pas reconnue).`)] };
+};
+function hostArgs(label, flags, valued, refused) {
+    return (argv) => {
+        const reasons = [];
+        const hosts = [];
+        for (let i = 0; i < argv.length; i++) {
+            const a = argv[i] ?? '';
+            if (refused.test(a))
+                reasons.push(block('app-args', `${label} : l’option « ${a} » est refusée (envoi continu ou paquets surdimensionnés).`));
+            else if (valued.test(a)) {
+                const value = argv[++i] ?? '';
+                if (!/^\d{1,5}$/.test(value))
+                    reasons.push(block('app-args', `${label} : valeur invalide pour « ${a} ».`));
+                else if (/^-n$/i.test(a) && Number(value) > 20)
+                    reasons.push(block('app-args', `${label} : 20 envois au maximum.`));
+            }
+            else if (flags.test(a))
+                continue;
+            else if (isSingleHost(a))
+                hosts.push(a.toLowerCase());
+            else
+                reasons.push(block('app-args', `${label} : argument « ${a} » non reconnu.`));
+        }
+        return { reasons, hosts };
+    };
+}
+const NMAP_FLAGS = /^(?:-Pn|-sV|-sT|-sS|-sU|-sn|-sC|-O|-A|-F|-n|-6|-v|-vv|--open|--reason|--version-light|--version-all|-T[0-4])$/;
+const NMAP_VALUED = new Set(['-p', '--top-ports', '--script', '--max-retries', '--host-timeout', '--version-intensity']);
+/**
+ * `--script` : une liste blanche, élément par élément. Une catégorie de nmap s'étend à tous ses scripts, et la plupart mêlent des
+ * scripts de lecture à d'autres. Relevé dans script.db (nmap 7.80) et la documentation de nmap :
+ * - `default` (celle de -sC et -A) et `version` n'ont aucun script intrusive, broadcast, brute, dos, exploit ni fuzzer. Deux
+ *   scripts de `default` sont external (http-open-proxy, socks-open-proxy : une requête vers un tiers, à travers le mandataire
+ *   de la cible) ;
+ * - `safe` est refusée : 40 scripts de diffusion sur le réseau local (hors de la cible), 27 qui écrivent à un service tiers, et
+ *   deux intrusive. `discovery` est refusée : 45 intrusive.
+ * Les scripts nommés sont dans `default`, `safe` ou `version`, sans intrusive, sauf ssl-enum-ciphers (discovery, intrusive) :
+ * nmap le dit intrusif parce qu'il ouvre beaucoup de connexions, « quite noisy ». Il n'essaie ni mot de passe ni faille, et la
+ * présentation le montre dans l'audit TLS.
+ * Un élément est l'un de ces noms, tel quel : ni joker, ni `all`, ni expression (and, or, not), ni `+`, ni chemin, ni fichier .nse.
+ * `--script-args` et les autres options `--script-*` ne sont pas dans les options admises : elles sont refusées.
+ */
+export const NMAP_CATEGORIES_ADMISES = ['default', 'version'];
+export const NMAP_SCRIPTS_ADMIS = ['banner', 'http-headers', 'http-methods', 'http-server-header', 'http-title', 'ssh-hostkey', 'ssh2-enum-algos', 'ssl-cert', 'ssl-enum-ciphers'];
+const NMAP_SCRIPTS = new Set([...NMAP_CATEGORIES_ADMISES, ...NMAP_SCRIPTS_ADMIS]);
+const scriptsAdmis = (value) => value.split(',').every((element) => NMAP_SCRIPTS.has(element));
+const REFUS_DU_SCRIPT = `--script n’accepte que les catégories ${NMAP_CATEGORIES_ADMISES.join(' et ')}, et les scripts de lecture ${NMAP_SCRIPTS_ADMIS.join(', ')}, séparés par des virgules, sans joker, expression ni fichier.`;
+/** nmap : options de découverte seulement, une cible à la fois, jamais d'évasion ni de script offensif. */
+export function nmapArgs(argv) {
+    const reasons = [];
+    const scanHosts = [];
+    if (argv.length > 0 && argv.every((a) => /^(?:-V|--version|-h|--help)$/.test(a)))
+        return { level: 'read', reasons };
+    for (let i = 0; i < argv.length; i++) {
+        const raw = argv[i] ?? '';
+        const eq = raw.startsWith('--') ? raw.indexOf('=') : -1;
+        const flag = eq > 0 ? raw.slice(0, eq) : raw;
+        if (/^-p[\dTU:,-]+$/.test(raw) || NMAP_FLAGS.test(raw))
+            continue;
+        if (NMAP_VALUED.has(flag)) {
+            const value = eq > 0 ? raw.slice(eq + 1) : (argv[++i] ?? '');
+            if (flag === '-p' && !/^[\dTU:,-]+$/.test(value))
+                reasons.push(block('app-args', 'nmap : liste de ports invalide.'));
+            else if (flag === '--top-ports' && !(Number(value) >= 1 && Number(value) <= 1000))
+                reasons.push(block('app-args', 'nmap : --top-ports accepte 1 à 1000.'));
+            else if (flag === '--script' && !scriptsAdmis(value))
+                reasons.push(block('app-args', `nmap : le script « ${value} » est refusé. ${REFUS_DU_SCRIPT}`));
+            else if (flag !== '-p' && flag !== '--top-ports' && flag !== '--script' && !/^[\w.]{1,12}$/.test(value))
+                reasons.push(block('app-args', `nmap : valeur invalide pour ${flag}.`));
+            continue;
+        }
+        if (raw.startsWith('-')) {
+            reasons.push(block('app-args', `nmap : l’option « ${raw} » n’est pas autorisée (évasion, usurpation, cibles aléatoires, sorties fichier et scripts offensifs sont exclus).`));
+            continue;
+        }
+        if (isSingleHost(raw))
+            scanHosts.push(raw.toLowerCase());
+        else
+            reasons.push(block('app-args', `nmap : « ${raw} » n’est pas une cible unique (plages, masques et jokers sont refusés).`));
+    }
+    if (scanHosts.length === 0 && reasons.length === 0)
+        reasons.push(block('app-args', 'nmap : aucune cible indiquée.'));
+    if (scanHosts.length > 1)
+        reasons.push(block('app-args', 'nmap : une seule cible par commande.'));
+    return { level: 'sensitive', reasons, scanHosts };
+}
+const CURL_FLAGS = /^(?:-[sSIiLvkf46]+|--head|--silent|--show-error|--location|--include|--compressed|--fail|--insecure|--ipv4|--ipv6|--verbose)$/;
+const CURL_VALUED = new Set(['-m', '--max-time', '--connect-timeout', '-A', '--user-agent', '-H', '--header', '-X', '--request', '-o', '--output', '-w', '--write-out']);
+/** curl.exe : requêtes de lecture (GET, HEAD, OPTIONS) vers http(s). Pas d'envoi de données ni de fichier. */
+export function curlArgs(argv) {
+    const reasons = [];
+    const hosts = [];
+    const writes = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] ?? '';
+        if (CURL_FLAGS.test(a))
+            continue;
+        if (CURL_VALUED.has(a)) {
+            const value = argv[++i] ?? '';
+            if ((a === '-X' || a === '--request') && !/^(?:GET|HEAD|OPTIONS)$/i.test(value))
+                reasons.push(block('app-args', `curl : la méthode ${value || '(vide)'} n’est pas autorisée (GET, HEAD ou OPTIONS).`));
+            if (a === '-o' || a === '--output')
+                writes.push(value);
+            continue;
+        }
+        if (a.startsWith('-')) {
+            reasons.push(block('app-args', `curl : l’option « ${a} » n’est pas autorisée (envoi de données, proxy et fichiers de configuration sont exclus).`));
+            continue;
+        }
+        const host = hostFromUrl(a);
+        if (host)
+            hosts.push(host);
+        else
+            reasons.push(block('app-args', `curl : « ${a} » n’est pas une URL http(s).`));
+    }
+    if (hosts.length === 0 && reasons.length === 0 && !argv.some((a) => /^(?:-V|--version)$/.test(a)))
+        reasons.push(block('app-args', 'curl : aucune URL indiquée.'));
+    return { level: 'sensitive', reasons, hosts, writes };
+}
+function ollamaArgs(argv) {
+    const sub = (argv[0] ?? '').toLowerCase();
+    if (['list', 'ls', 'ps', 'show', '--version', '-v', 'help', ''].includes(sub))
+        return { level: 'read', reasons: [] };
+    if (['run', 'pull', 'stop', 'create', 'cp'].includes(sub))
+        return { level: 'sensitive', reasons: [warn('ollama', `ollama ${sub} modifie les modèles installés ou en charge un en mémoire.`)] };
+    return { reasons: [block('app-args', `ollama ${sub} n’est pas autorisé depuis Prométhée.`)] };
+}
+const anyArgs = () => ({ reasons: [] });
+addApp('whoami hostname systeminfo getmac tasklist driverquery qwinsta nslookup findstr', { level: 'read', category: 'système', system: true, args: anyArgs });
+addApp('ipconfig', { level: 'read', category: 'réseau', system: true, args: only('ipconfig', /^\/(?:all|displaydns|allcompartments|\?)$/i) });
+addApp('arp', { level: 'read', category: 'réseau', system: true, args: only('arp', /^(?:-a|-g|-v|\d{1,3}(?:\.\d{1,3}){3})$/i) });
+addApp('route', {
+    level: 'read',
+    category: 'réseau',
+    system: true,
+    args: (argv) => ({ reasons: /^print$/i.test(argv[0] ?? '') ? [] : [block('app-args', 'route : seul « route print » est autorisé.')] }),
+});
+addApp('netstat', { level: 'read', category: 'réseau', system: true, args: only('netstat', /^-[a-zA-Z]{1,8}$/) });
+addApp('nbtstat', { level: 'read', category: 'réseau', system: true, args: only('nbtstat', /^(?:-[aAcnrSs]|[\w.-]{1,64})$/) });
+addApp('ping', { level: 'read', category: 'réseau', system: true, args: hostArgs('ping', /^-(?:4|6|a)$/i, /^-(?:n|w|i)$/i, /^-(?:t|l|f)$/i) });
+addApp('tracert pathping', { level: 'read', category: 'réseau', system: true, args: hostArgs('tracert', /^-(?:4|6|d)$/i, /^-(?:h|w|q|p)$/i, /^$/) });
+addApp('curl', { level: 'sensitive', category: 'réseau', system: true, note: 'envoie une requête web', args: curlArgs });
+addApp('nmap', { level: 'sensitive', category: 'réseau', system: false, note: 'teste des ports : cible dans le périmètre autorisé', args: nmapArgs });
+addApp('ollama', { level: 'read', category: 'IA locale', system: false, args: ollamaArgs });
+/** winget : chercher et lister sont des lectures ; installer, mettre à jour ou désinstaller doivent être débloqués. */
+function wingetArgs(argv) {
+    const sub = (argv[0] ?? '').toLowerCase();
+    if (['search', 'list', 'show', 'source', '--version', '-v', '--info', ''].includes(sub) && !argv.some((a) => /^(?:add|remove|reset|update)$/i.test(a)))
+        return { level: 'read', reasons: [] };
+    return { level: 'sensitive', reasons: [], needsUnlock: `winget ${sub} installe, met à jour ou retire un logiciel` };
+}
+addApp('winget', { level: 'read', category: 'système', system: false, note: 'recherche en lecture, installation à débloquer', args: wingetArgs, unlockable: true });
+addApp('taskkill shutdown net net1 netsh sc reg schtasks icacls takeown attrib choco', {
+    level: 'destructive',
+    category: 'système',
+    system: false,
+    note: 'modifie le système',
+});
+addApp('powershell pwsh cmd wscript cscript mshta rundll32 regsvr32 certutil bitsadmin diskpart bcdedit vssadmin wbadmin cipher format wmic msiexec runas forfiles wsl bash sh ssh ftp tftp', { level: 'forbidden', category: 'interpréteurs', system: false, note: 'interpréteur ou outil système qui échappe à l’analyse' });
+export const CMDLETS = cmdlets;
+export const APPS = apps;
+/** Nom de base d'une application : « C:\Windows\System32\whoami.exe » donne « whoami ». */
+export function appKey(nameOrPath) {
+    const base = nameOrPath.split(/[\\/]/).pop() ?? nameOrPath;
+    const dot = base.lastIndexOf('.');
+    return dot > 0 ? { key: base.slice(0, dot).toLowerCase(), ext: base.slice(dot).toLowerCase() } : { key: base.toLowerCase(), ext: '' };
+}

package/lib/server/engine/decoder.js

@@ -0,0 +1,91 @@
+/**
+ * Décodage de la sortie de PowerShell.
+ *
+ * PowerShell 5.1 et les outils Windows (ipconfig, whoami…) écrivent dans la page de codes OEM de
+ * la console (850 sur un Windows français), alors que curl, nmap ou git écrivent en UTF-8.
+ * Chaque ligne est donc décodée en UTF-8 si elle est valide, sinon avec la table OEM lue sur la machine.
+ */
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+export function decodeLine(bytes, oemTable) {
+    let ascii = true;
+    for (const b of bytes) {
+        if (b >= 0x80) {
+            ascii = false;
+            break;
+        }
+    }
+    if (ascii)
+        return Buffer.from(bytes).toString('latin1');
+    try {
+        return utf8.decode(bytes);
+    }
+    catch {
+        if (!oemTable || oemTable.length !== 128)
+            return Buffer.from(bytes).toString('latin1');
+        let out = '';
+        for (const b of bytes)
+            out += b < 0x80 ? String.fromCharCode(b) : oemTable.charAt(b - 0x80);
+        return out;
+    }
+}
+export function createLineDecoder(oemTable) {
+    let pending = Buffer.alloc(0);
+    return {
+        push(chunk) {
+            pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
+            let out = '';
+            let start = 0;
+            let nl = pending.indexOf(0x0a, start);
+            while (nl >= 0) {
+                const end = nl > start && pending[nl - 1] === 0x0d ? nl - 1 : nl;
+                out += `${decodeLine(pending.subarray(start, end), oemTable)}\n`;
+                start = nl + 1;
+                nl = pending.indexOf(0x0a, start);
+            }
+            pending = pending.subarray(start);
+            return out;
+        },
+        flush() {
+            if (pending.length === 0)
+                return '';
+            const text = decodeLine(pending, oemTable);
+            pending = Buffer.alloc(0);
+            return text;
+        },
+    };
+}
+const ERR_LOCATION = /^(?:Au caractère|At) (?:Ligne|line):\d+\s*(?::|char:)\s*\d+\s*$/;
+const ERR_DETAIL = /^\s+\+ (?:CategoryInfo|FullyQualifiedErrorId)\s*:/;
+/**
+ * Allège les erreurs de PowerShell : retire l'emplacement dans le script, le soulignement et
+ * les lignes CategoryInfo, pour ne garder que le message.
+ */
+export function createErrorTidier() {
+    let inLocation = false;
+    let inDetail = false;
+    return (text) => {
+        const kept = [];
+        const lines = text.split('\n');
+        const last = lines.pop() ?? '';
+        for (const raw of lines) {
+            const line = raw.replace(/\r$/, '');
+            if (ERR_LOCATION.test(line)) {
+                inLocation = true;
+                continue;
+            }
+            if (inLocation && line.startsWith('+ '))
+                continue;
+            inLocation = false;
+            if (ERR_DETAIL.test(line)) {
+                inDetail = true;
+                continue;
+            }
+            if (inDetail && line.startsWith(' ') && line.trim() !== '')
+                continue;
+            inDetail = false;
+            kept.push(line.trimEnd());
+        }
+        const body = kept.join('\n');
+        return (kept.length > 0 ? `${body}\n` : '') + last;
+    };
+}

package/lib/server/engine/engine.js

@@ -0,0 +1,194 @@
+/**
+ * Moteur d'exécution : le seul chemin par lequel une commande peut s'exécuter.
+ *
+ *   1. preview()  analyse la commande, applique la politique, délivre un ticket à usage unique ;
+ *   2. start()    exige ce ticket et la confirmation humaine, puis lance PowerShell ;
+ *   3. chaque refus et chaque exécution sont écrits dans le journal.
+ *
+ * L'IA ne peut qu'appeler preview() : elle propose, l'humain confirme.
+ */
+import { randomBytes } from 'node:crypto';
+import { AppError, badRequest } from '../errors.js';
+import { resolveDirectory } from './paths.js';
+import { evaluate, modulesToPreload } from './policy.js';
+const TICKET_TTL_MS = 5 * 60_000;
+const MAX_RUNNING = 4;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+export class Engine {
+    tickets = new Map();
+    active = new Map();
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get available() {
+        return this.deps.probe.available;
+    }
+    get running() {
+        return this.active.size;
+    }
+    defaultCwd() {
+        return this.deps.settings().engine.roots[0] ?? this.deps.home;
+    }
+    /** Valide un changement de dossier demandé par le terminal (« cd »), sans passer par PowerShell. */
+    resolveCwd(from, to) {
+        const result = resolveDirectory(from, to, this.deps.settings().engine.roots, this.deps.home);
+        if (!result.ok)
+            throw badRequest(result.message, result.code);
+        return result.cwd;
+    }
+    checkCwd(cwd) {
+        return this.resolveCwd(cwd, '.');
+    }
+    policyContext(cwd) {
+        const settings = this.deps.settings();
+        return {
+            cwd,
+            roots: settings.engine.roots,
+            home: this.deps.home,
+            custom: settings.allowlist.custom,
+            unlocked: settings.allowlist.unlocked,
+            targets: this.deps.targets(),
+            systemRoot: this.deps.systemRoot,
+        };
+    }
+    async preview(command, cwd, origin) {
+        if (!this.available)
+            throw new AppError('engine_down', 503, this.deps.probe.error ?? 'Le moteur PowerShell n’est pas disponible.');
+        const text = command.trim();
+        if (/`\s*$/.test(text))
+            throw badRequest('La commande ne peut pas se terminer par un accent grave (continuation de ligne).');
+        const dir = this.checkCwd(cwd ?? this.defaultCwd());
+        const analysis = await this.deps.analyzer.analyze(text);
+        const verdict = evaluate(analysis, this.policyContext(dir));
+        if (verdict.level === 'denied') {
+            this.deps.journal.add({
+                kind: 'refusal',
+                outcome: 'refused',
+                title: text.length > 120 ? `${text.slice(0, 120)}…` : text,
+                detail: verdict.reasons.filter((r) => r.severity === 'block').map((r) => r.message).join('\n'),
+                data: { command: text, cwd: dir, origin, codes: verdict.reasons.filter((r) => r.severity === 'block').map((r) => r.code) },
+            });
+            return { ticket: null, command: text, cwd: dir, verdict, expiresAt: null };
+        }
+        const now = Date.now();
+        for (const [id, t] of this.tickets)
+            if (t.expiresAt < now)
+                this.tickets.delete(id);
+        if (this.tickets.size > 200)
+            this.tickets.clear();
+        const ticket = randomBytes(16).toString('hex');
+        const expiresAt = now + TICKET_TTL_MS;
+        this.tickets.set(ticket, { command: text, cwd: dir, analysis, verdict, modules: modulesToPreload(analysis), origin, expiresAt });
+        return { ticket, command: text, cwd: dir, verdict, expiresAt };
+    }
+    /** Lance la commande d'un ticket. Toutes les vérifications ont lieu avant le premier événement. */
+    start(ticketId, options) {
+        const ticket = this.tickets.get(ticketId);
+        if (!ticket || ticket.expiresAt < Date.now()) {
+            this.tickets.delete(ticketId);
+            throw new AppError('ticket_expired', 410, 'Cette prévisualisation a expiré ou a déjà servi. Relance la commande.');
+        }
+        const settings = this.deps.settings();
+        // Les réglages ou le périmètre ont pu changer depuis la prévisualisation : la politique tranche à nouveau.
+        const current = evaluate(ticket.analysis, this.policyContext(ticket.cwd));
+        if (current.level === 'denied' || (current.level === 'sensitive' && ticket.verdict.level === 'read')) {
+            this.tickets.delete(ticketId);
+            throw new AppError('policy_changed', 409, 'Les réglages ont changé depuis la prévisualisation : relance la commande pour la faire réévaluer.');
+        }
+        if (ticket.verdict.level === 'sensitive' && options.acknowledge !== true)
+            throw new AppError('ack_required', 428, 'Cette commande est sensible : coche la case de confirmation avant de l’exécuter.');
+        if (options.confirmation === 'auto' && (ticket.verdict.level !== 'read' || ticket.origin !== 'terminal' || settings.engine.confirmRead))
+            throw new AppError('confirmation_required', 428, 'Cette commande demande une confirmation humaine.');
+        if (this.active.size >= MAX_RUNNING)
+            throw new AppError('busy', 429, `${MAX_RUNNING} commandes sont déjà en cours. Attends la fin de l’une d’elles ou annule-la.`);
+        this.tickets.delete(ticketId);
+        const execId = randomBytes(8).toString('hex');
+        const handle = this.deps.runner.run({
+            command: ticket.command,
+            cwd: ticket.cwd,
+            modules: ticket.modules,
+            constrained: settings.engine.constrainedLanguage,
+            timeoutMs: settings.engine.timeoutSec * 1000,
+            maxBytes: MAX_OUTPUT_BYTES,
+        });
+        this.active.set(execId, handle);
+        const { journal } = this.deps;
+        const active = this.active;
+        async function* stream() {
+            let tail = '';
+            let ended = false;
+            try {
+                yield { type: 'start', execId, startedAt: new Date().toISOString() };
+                for await (const event of handle.events) {
+                    if (event.type === 'out') {
+                        tail = (tail + event.text).slice(-800);
+                        yield event;
+                        continue;
+                    }
+                    ended = true;
+                    const outcome = event.cancelled ? 'cancelled' : event.timedOut || event.exitCode !== 0 ? 'error' : 'ok';
+                    journal.add({
+                        kind: 'command',
+                        outcome,
+                        title: ticket && ticket.command.length > 120 ? `${ticket.command.slice(0, 120)}…` : (ticket?.command ?? ''),
+                        detail: event.timedOut ? `Arrêtée après ${Math.round(event.durationMs / 1000)} s (délai dépassé).` : event.cancelled ? 'Annulée par toi.' : `Code de sortie ${event.exitCode ?? '?'} en ${event.durationMs} ms.`,
+                        data: {
+                            command: ticket?.command,
+                            cwd: ticket?.cwd,
+                            level: ticket?.verdict.level,
+                            origin: ticket?.origin,
+                            confirmation: options.confirmation,
+                            exitCode: event.exitCode,
+                            durationMs: event.durationMs,
+                            timedOut: event.timedOut,
+                            truncated: event.truncated,
+                            tail,
+                        },
+                    });
+                    yield event;
+                }
+            }
+            finally {
+                active.delete(execId);
+                // Le client a coupé la connexion avant la fin : on arrête la commande plutôt que de la laisser tourner sans témoin.
+                if (!ended)
+                    handle.cancel();
+            }
+        }
+        return { execId, events: stream() };
+    }
+    cancel(execId) {
+        const handle = this.active.get(execId);
+        if (!handle)
+            return false;
+        handle.cancel();
+        return true;
+    }
+    cancelAll() {
+        for (const handle of this.active.values())
+            handle.cancel();
+    }
+    /** Exécute jusqu'au bout et rassemble la sortie (utilisé par le cerveau et les audits). */
+    async collect(execution, onEvent) {
+        let output = '';
+        let summary = { exitCode: null, durationMs: 0, cancelled: false, timedOut: false, truncated: false, output: '' };
+        for await (const event of execution.events) {
+            onEvent?.(event);
+            if (event.type === 'out' && output.length < 200_000)
+                output += event.text;
+            else if (event.type === 'end')
+                summary = { exitCode: event.exitCode, durationMs: event.durationMs, cancelled: event.cancelled, timedOut: event.timedOut, truncated: event.truncated, output: '' };
+        }
+        return { ...summary, output };
+    }
+    /** Commande fixe d'un module d'audit : elle doit être classée « lecture » par la même politique. */
+    async runRead(command, cwd) {
+        const preview = await this.preview(command, cwd, 'audit');
+        if (preview.verdict.level !== 'read' || !preview.ticket) {
+            const why = preview.verdict.reasons.find((r) => r.severity === 'block')?.message ?? 'commande non classée en lecture';
+            throw new AppError('audit_command_refused', 500, `Commande d’audit refusée par la politique : ${why}`);
+        }
+        return this.collect(this.start(preview.ticket, { confirmation: 'human' }));
+    }
+}

package/lib/server/engine/paths.js

@@ -0,0 +1,129 @@
+/** Périmètre : dossiers autorisés en écriture, et hôtes autorisés pour les tests de ports. */
+import fs from 'node:fs';
+import path from 'node:path';
+const win = path.win32;
+const defaultRealpath = (p) => {
+    try {
+        return fs.realpathSync.native(p);
+    }
+    catch {
+        return null;
+    }
+};
+/** Vrai si « child » est « root » ou se trouve dedans (comparaison insensible à la casse). */
+export function isInside(child, root) {
+    const rel = win.relative(root.toLowerCase(), child.toLowerCase());
+    return rel === '' || (!rel.startsWith('..') && !win.isAbsolute(rel));
+}
+/**
+ * Suit les jonctions et liens du plus long dossier existant, pour qu'un lien placé dans le
+ * périmètre ne permette pas d'écrire en dehors.
+ */
+function realAncestor(absolute, realpath) {
+    const parts = absolute.split(/[\\/]+/);
+    const firstWild = parts.findIndex((part) => /[*?[\]]/.test(part));
+    const fixed = firstWild < 0 ? parts : parts.slice(0, firstWild);
+    const tail = firstWild < 0 ? [] : parts.slice(firstWild);
+    for (let n = fixed.length; n > 0; n--) {
+        const candidate = fixed.slice(0, n).join('\\') + (n === 1 ? '\\' : '');
+        const real = realpath(candidate);
+        if (real)
+            return win.join(real, ...fixed.slice(n), ...tail);
+    }
+    return absolute;
+}
+export function classifyPath(value, ctx) {
+    const v = value.trim();
+    if (/^[\\/]{2}/.test(v))
+        return { kind: 'unc', absolute: v, inScope: false };
+    // HKLM:\…, Env:…, Registry::…, Microsoft.PowerShell.Core\FileSystem::… (deux caractères au moins avant « : »)
+    if (/^[A-Za-z][\w.\\-]+:/.test(v))
+        return { kind: 'provider', absolute: v, inScope: false };
+    const expanded = v === '~' || /^~[\\/]/.test(v) ? ctx.home + v.slice(1) : v;
+    const absolute = win.resolve(ctx.cwd, expanded);
+    const realpath = ctx.realpath ?? defaultRealpath;
+    const real = realAncestor(absolute, realpath);
+    const inScope = ctx.roots.some((root) => isInside(real, realpath(root) ?? win.resolve(root)));
+    return { kind: 'file', absolute, inScope };
+}
+/**
+ * Valide un changement de dossier (« cd ») : le dossier doit exister et se trouver dans les dossiers autorisés.
+ * Renvoie le chemin réel, ou une raison lisible.
+ */
+export function resolveDirectory(from, to, roots, home) {
+    const found = existingDirectory(from, to, home);
+    if (!found.ok)
+        return found;
+    if (!roots.some((root) => isInside(found.cwd, root)))
+        return { ok: false, code: 'cwd_out_of_scope', message: `« ${found.cwd} » est en dehors des dossiers autorisés (${roots.join(', ')}).` };
+    return found;
+}
+/** Chemin réel d'un dossier local existant (les jonctions sont suivies). Les chemins réseau sont refusés. */
+export function existingDirectory(from, to, home) {
+    const expanded = to === '~' || /^~[\\/]/.test(to) ? home + to.slice(1) : to;
+    if (/^[\\/]{2}/.test(expanded) || /^[\\/]{2}/.test(from))
+        return { ok: false, code: 'bad_cwd', message: 'Les chemins réseau ne sont pas autorisés.' };
+    const wanted = win.resolve(from, expanded);
+    try {
+        const real = fs.realpathSync.native(wanted);
+        if (!fs.statSync(real).isDirectory())
+            throw new Error('pas un dossier');
+        if (/^[\\/]{2}/.test(real))
+            return { ok: false, code: 'bad_cwd', message: 'Les chemins réseau ne sont pas autorisés.' };
+        return { ok: true, cwd: real };
+    }
+    catch {
+        return { ok: false, code: 'bad_cwd', message: `Le dossier « ${wanted} » n’existe pas.` };
+    }
+}
+export function isLoopback(host) {
+    const h = host.toLowerCase().replace(/^\[|\]$/g, '');
+    return h === 'localhost' || h === '::1' || /^127(?:\.\d{1,3}){3}$/.test(h);
+}
+export function hostInScope(host, targets) {
+    const h = host.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    if (isLoopback(h))
+        return true;
+    return targets.some((t) => t.host === h || (t.includeSubdomains && h.endsWith(`.${t.host}`)));
+}
+const HOSTNAME = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/i;
+const IPV6 = /^[0-9a-f:]{2,39}$/i;
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
+/** Nom d'hôte ou adresse IP unique : ni plage, ni masque, ni joker. */
+export function isSingleHost(value) {
+    const v = value.replace(/^\[|\]$/g, '');
+    // Que des chiffres, des points et des tirets : ce doit être une adresse IPv4 exacte, pas une plage (10.0.0.1-50).
+    if (/^[\d.-]+$/.test(v))
+        return IPV4.test(v);
+    return (HOSTNAME.test(v) && v.length <= 253) || (IPV6.test(v) && v.includes(':'));
+}
+const IPV4_INSIDE = /(?<![\d.])((?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d))(\/\d{1,2}|-\d{1,3})?(?![\d.])/g;
+const URL_HOST = /\b[a-z][a-z0-9+.-]*:\/\/(?:[^\/\s@]*@)?(\[[0-9a-f:]+\]|[^\/\s:?#]+)/gi;
+/**
+ * Machines qu'un argument désigne en clair : adresses IPv4 (seules, avec un port, un masque ou une plage) et
+ * hôtes d'URL. Sert à contrôler le périmètre d'une commande que la politique ne sait pas analyser
+ * (« python scan.py 10.0.0.5 »). Une plage ou un masque est rendu tel quel : il ne peut jamais être dans le périmètre.
+ */
+export function mentionedHosts(value) {
+    const hosts = [];
+    for (const m of value.matchAll(URL_HOST))
+        if (!/^file:/i.test(m[0]))
+            hosts.push((m[1] ?? '').toLowerCase().replace(/^\[|\]$/g, ''));
+    for (const m of value.matchAll(IPV4_INSIDE))
+        hosts.push(`${m[1] ?? ''}${m[2] ?? ''}`);
+    return [...new Set(hosts.filter(Boolean))];
+}
+/** Hôte d'une URL http(s), ou null si ce n'en est pas une. */
+export function hostFromUrl(value) {
+    const candidate = /^[a-z][a-z0-9+.-]*:\/\//i.test(value) ? value : `http://${value}`;
+    try {
+        const url = new URL(candidate);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+        return host && isSingleHost(host) ? host : null;
+    }
+    catch {
+        return null;
+    }
+}