@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/engine/policy.js

@@ -0,0 +1,397 @@
+import { APPS, CMDLETS, appKey } from './catalog.js';
+import { classifyPath, hostFromUrl, hostInScope, isInside, isSingleHost } from './paths.js';
+const ALLOWED_NODES = new Set([
+    'ScriptBlockAst', 'NamedBlockAst', 'StatementBlockAst', 'PipelineAst', 'CommandAst', 'CommandExpressionAst', 'CommandParameterAst',
+    'StringConstantExpressionAst', 'ExpandableStringExpressionAst', 'ConstantExpressionAst', 'VariableExpressionAst', 'MemberExpressionAst',
+    'InvokeMemberExpressionAst', 'TypeExpressionAst', 'ConvertExpressionAst', 'TypeConstraintAst', 'ArrayLiteralAst', 'ArrayExpressionAst',
+    'HashtableAst', 'ParenExpressionAst', 'SubExpressionAst', 'BinaryExpressionAst', 'UnaryExpressionAst', 'IndexExpressionAst',
+    'ScriptBlockExpressionAst', 'AssignmentStatementAst', 'IfStatementAst', 'ForEachStatementAst', 'ForStatementAst', 'WhileStatementAst',
+    'DoWhileStatementAst', 'DoUntilStatementAst', 'SwitchStatementAst', 'TryStatementAst', 'CatchClauseAst', 'ThrowStatementAst',
+    'ReturnStatementAst', 'BreakStatementAst', 'ContinueStatementAst', 'ExitStatementAst', 'FileRedirectionAst', 'MergingRedirectionAst',
+]);
+const NODE_LABELS = {
+    FunctionDefinitionAst: 'définition de fonction',
+    ParamBlockAst: 'bloc param()',
+    ParameterAst: 'bloc param()',
+    AttributeAst: 'attribut',
+    TrapStatementAst: 'instruction trap',
+    DataStatementAst: 'section data',
+    TypeDefinitionAst: 'définition de classe',
+    UsingStatementAst: 'instruction using',
+    UsingExpressionAst: 'variable $using:',
+    DynamicKeywordStatementAst: 'mot-clé dynamique',
+    ConfigurationDefinitionAst: 'configuration DSC',
+    BlockStatementAst: 'bloc parallel/sequence',
+};
+const normType = (t) => t.toLowerCase().replace(/^system\./, '').replace(/\[\]$/, '');
+const SAFE_TYPES = new Set([
+    'int', 'int32', 'int64', 'long', 'uint32', 'uint64', 'double', 'single', 'float', 'decimal', 'bool', 'boolean', 'string', 'char', 'byte',
+    'datetime', 'timespan', 'version', 'guid', 'ipaddress', 'net.ipaddress', 'uri', 'regex', 'text.regularexpressions.regex', 'math', 'convert',
+    'array', 'hashtable', 'pscustomobject', 'psobject', 'object', 'void', 'ordered', 'switch',
+]);
+/** Méthodes statiques autorisées, par type. « * » : toutes. */
+const STATIC_MEMBERS = {
+    math: '*',
+    char: '*',
+    datetime: new Set(['now', 'utcnow', 'today', 'parse', 'parseexact', 'minvalue', 'maxvalue']),
+    timespan: new Set(['fromseconds', 'fromminutes', 'fromhours', 'fromdays', 'frommilliseconds', 'parse', 'zero']),
+    string: new Set(['isnullorempty', 'isnullorwhitespace', 'join', 'format', 'concat', 'empty']),
+    convert: new Set(['toint32', 'toint64', 'tostring', 'todouble', 'toboolean', 'tobyte', 'tochar', 'tobase64string', 'frombase64string']),
+    regex: new Set(['match', 'matches', 'ismatch', 'replace', 'escape', 'split']),
+    'text.regularexpressions.regex': new Set(['match', 'matches', 'ismatch', 'replace', 'escape', 'split']),
+    guid: new Set(['newguid', 'parse', 'empty']),
+    ipaddress: new Set(['parse', 'loopback', 'any']),
+    'net.ipaddress': new Set(['parse', 'loopback', 'any']),
+    version: new Set(['parse']),
+    int: new Set(['parse', 'maxvalue', 'minvalue']),
+    int32: new Set(['parse', 'maxvalue', 'minvalue']),
+    int64: new Set(['parse', 'maxvalue', 'minvalue']),
+    double: new Set(['parse', 'maxvalue', 'minvalue']),
+};
+const INSTANCE_METHODS = new Set([
+    'tostring', 'toupper', 'tolower', 'toupperinvariant', 'tolowerinvariant', 'trim', 'trimstart', 'trimend', 'split', 'replace', 'contains',
+    'startswith', 'endswith', 'substring', 'indexof', 'lastindexof', 'padleft', 'padright', 'equals', 'compareto', 'adddays', 'addhours',
+    'addminutes', 'addseconds', 'addmonths', 'addyears', 'tolocaltime', 'touniversaltime', 'toshortdatestring', 'toshorttimestring',
+]);
+const FORBIDDEN_VARIABLES = new Set(['executioncontext', 'psdefaultparametervalues', 'psmoduleautoloadingpreference']);
+const VARIABLE_SCOPES = new Set(['global', 'local', 'script', 'private']);
+const SCRIPT_HOST_EXTENSIONS = new Set(['.bat', '.cmd', '.ps1', '.psm1', '.vbs', '.vbe', '.js', '.jse', '.wsf', '.hta', '.msi', '.lnk']);
+const block = (code, message) => ({ code, message, severity: 'block' });
+/** Refus qui tient même en politique souple : destruction, cible hors périmètre, protections de Windows. */
+const floor = (code, message) => ({ code, message, severity: 'block', floor: true });
+/** Catégories interdites qui sont aussi des planchers. Les interpréteurs n'en sont pas : la politique souple les laisse à ta validation. */
+const FLOOR_CATEGORIES = new Set(['protections', 'disques']);
+const warn = (code, message) => ({ code, message, severity: 'warn' });
+const info = (code, message) => ({ code, message, severity: 'info' });
+/** Valeurs constantes d'un élément (une chaîne, ou une liste de chaînes). null : non vérifiable. */
+function constants(el) {
+    if (!el)
+        return null;
+    if (el.k === 'p')
+        return el.a ? constants(el.a) : null;
+    if (el.k === 's' || el.k === 'n')
+        return [el.v ?? ''];
+    if (el.k === 'l' && el.i) {
+        const out = [];
+        for (const item of el.i) {
+            const values = constants(item);
+            if (!values)
+                return null;
+            out.push(...values);
+        }
+        return out;
+    }
+    return null;
+}
+function boundParam(cmd, names) {
+    const wanted = new Set(names.map((n) => n.toLowerCase()));
+    return cmd.bound.filter((b) => wanted.has(b.name.toLowerCase()));
+}
+/** Arguments d'une application, en texte. null si l'un d'eux n'est pas une constante. */
+function appArgv(cmd) {
+    const argv = [];
+    for (const el of cmd.elements) {
+        if (el.k === 's' || el.k === 'n')
+            argv.push(el.v ?? '');
+        else if (el.k === 'p') {
+            const raw = el.t ?? `-${el.n ?? ''}`;
+            if (el.a) {
+                const values = constants(el.a);
+                if (!values)
+                    return null;
+            }
+            argv.push(raw);
+        }
+        else if (el.k === 'l') {
+            const values = constants(el);
+            if (!values)
+                return null;
+            argv.push(values.join(','));
+        }
+        else
+            return null;
+    }
+    return argv;
+}
+function checkWritePath(value, label, ctx, draft) {
+    const resolved = classifyPath(value, ctx);
+    if (resolved.kind === 'unc')
+        draft.reasons.push(floor('unc-path', `${label} : les chemins réseau (\\\\serveur\\partage) sont refusés.`));
+    else if (resolved.kind === 'provider')
+        draft.reasons.push(block('provider-write', `${label} : écriture hors du système de fichiers (« ${value} ») refusée.`));
+    else if (!resolved.inScope)
+        draft.reasons.push(block('out-of-scope', `${label} : « ${resolved.absolute} » est en dehors des dossiers autorisés en écriture.`));
+    else if (isInside(resolved.absolute, ctx.systemRoot))
+        draft.reasons.push(block('out-of-scope', `${label} : écriture dans le dossier de Windows refusée.`));
+    else
+        draft.writes.push(resolved.absolute);
+}
+function checkReadPath(value, label, ctx, draft) {
+    const resolved = classifyPath(value, ctx);
+    // Les chemins réseau sont déjà refusés pour toute la commande (voir evaluateCmdlet).
+    if (resolved.kind === 'file' && !resolved.inScope)
+        draft.reasons.push(info('read-outside', `${label} lit en dehors de tes dossiers autorisés : ${resolved.absolute}`));
+}
+function checkScanHost(host, label, ctx, draft) {
+    draft.network.push(host);
+    if (!hostInScope(host, ctx.targets))
+        draft.reasons.push({ ...floor('target-out-of-scope', `${label} : « ${host} » n’est pas dans ton périmètre autorisé. Déclare cette cible dans Audits › Périmètre si elle t’appartient ou si tu as une autorisation écrite.`), plain: `${label} : « ${host} » n’est pas dans ton périmètre autorisé.`, subject: host });
+}
+function evaluateCmdlet(cmd, rule, label, ctx, draft) {
+    const writing = rule.level !== 'read';
+    const resolvedName = (cmd.resolved ?? '').toLowerCase();
+    if (cmd.bindErrors.length > 0) {
+        const text = `${label} : paramètres non reconnus ou ambigus (${cmd.bindErrors[0]}).`;
+        draft.reasons.push(writing ? block('bind-error', text) : warn('bind-error', text));
+    }
+    if (cmd.elements.some((el) => el.k === 'v' && el.splat))
+        draft.reasons.push(block('splat', `${label} : les arguments éclatés (@variable) ne sont pas vérifiables.`));
+    if (!rule.blocks && cmd.elements.some((el) => el.k === 'b' || (el.k === 'p' && el.a?.k === 'b')))
+        draft.reasons.push(block('scriptblock-arg', `${label} : cette commande ne doit pas recevoir de bloc de script.`));
+    // « ForEach-Object Kill » ou « -MemberName Delete » appellerait une méthode sans que l'analyse la voie.
+    if (resolvedName === 'foreach-object') {
+        const blockParam = (n) => ['process', 'begin', 'end'].some((full) => n.length > 0 && full.startsWith(n.toLowerCase()));
+        const onlyBlocks = cmd.elements.every((el) => el.k === 'b' || (el.k === 'p' && blockParam(el.n ?? '') && (!el.a || el.a.k === 'b')));
+        if (!onlyBlocks)
+            draft.reasons.push(block('member-name', 'ForEach-Object : seul un bloc de script { … } est accepté (pas de nom de propriété ou de méthode).'));
+    }
+    // Chemins réseau, où qu'ils apparaissent : ils enverraient les identifiants Windows au serveur visé.
+    const everyConstant = cmd.elements.flatMap((el) => constants(el) ?? []);
+    if (everyConstant.some((v) => /^[\\/]{2}/.test(v)))
+        draft.reasons.push(floor('unc-path', `${label} : les chemins réseau (\\\\serveur\\partage) sont refusés, ils enverraient tes identifiants Windows au serveur visé.`));
+    // Interrogation d'une autre machine par un paramètre générique.
+    for (const b of boundParam(cmd, ['ComputerName', 'CimSession']).filter((x) => !(rule.host ?? []).includes(x.name))) {
+        const values = constants(b.el);
+        draft.sensitive = true;
+        if (!values)
+            draft.reasons.push(floor('dynamic-target', `${label} : la machine visée par -${b.name} n’est pas une constante.`));
+        else {
+            draft.network.push(...values.map((v) => v.toLowerCase()));
+            draft.reasons.push(warn('remote-host', `${label} interroge une autre machine : ${values.join(', ')}.`));
+        }
+    }
+    for (const b of boundParam(cmd, rule.write ?? [])) {
+        const values = constants(b.el);
+        if (!values)
+            draft.reasons.push(block('dynamic-path', `${label} : le chemin de -${b.name} n’est pas une constante, il ne peut pas être vérifié.`));
+        else
+            for (const v of values)
+                checkWritePath(v, `${label} -${b.name}`, ctx, draft);
+    }
+    if (writing && rule.require && boundParam(cmd, rule.require).length === 0)
+        draft.reasons.push(block('missing-path', `${label} : la cible doit être donnée explicitement (-${rule.require[0]}), pas par le pipeline.`));
+    for (const b of boundParam(cmd, rule.read ?? [])) {
+        const values = constants(b.el);
+        if (values)
+            for (const v of values)
+                checkReadPath(v, label, ctx, draft);
+    }
+    if (resolvedName === 'rename-item') {
+        const newName = constants(boundParam(cmd, ['NewName'])[0]?.el);
+        if (!newName || newName.some((n) => /[\\/:]/.test(n)))
+            draft.reasons.push(block('dynamic-path', 'Rename-Item : -NewName doit être un simple nom de fichier constant.'));
+    }
+    const scanning = (rule.scan ?? []).length > 0 && boundParam(cmd, rule.scan ?? []).length > 0;
+    if (scanning)
+        draft.sensitive = true;
+    for (const b of boundParam(cmd, rule.host ?? [])) {
+        const values = constants(b.el);
+        if (!values) {
+            if (scanning)
+                draft.reasons.push(floor('dynamic-target', `${label} : la cible n’est pas une constante, elle ne peut pas être vérifiée.`));
+            else if (writing)
+                draft.reasons.push(warn('dynamic-target', `${label} : la cible est calculée, vérifie-la avant de confirmer.`));
+            continue;
+        }
+        for (const v of values) {
+            const host = b.name.toLowerCase() === 'uri' ? hostFromUrl(v) : isSingleHost(v) ? v.toLowerCase() : null;
+            if (!host)
+                draft.reasons.push(floor('bad-target', `${label} : « ${v} » n’est pas ${b.name.toLowerCase() === 'uri' ? 'une URL http(s)' : 'un hôte unique'}.`));
+            else if (scanning)
+                checkScanHost(host, label, ctx, draft);
+            else
+                draft.network.push(host);
+        }
+    }
+    if (scanning && boundParam(cmd, rule.host ?? []).length === 0)
+        draft.reasons.push(floor('dynamic-target', `${label} : indique la cible avec -ComputerName.`));
+    // Start-Process débloqué : il ne doit quand même jamais lancer un interpréteur interdit ni un script.
+    if (resolvedName === 'start-process') {
+        const programs = constants(boundParam(cmd, ['FilePath'])[0]?.el);
+        if (!programs)
+            draft.reasons.push(block('dynamic-args', 'Start-Process : le programme à lancer doit être une constante.'));
+        else
+            for (const program of programs) {
+                const { key, ext } = appKey(program);
+                if (APPS.get(key)?.level === 'forbidden' || SCRIPT_HOST_EXTENSIONS.has(ext))
+                    draft.reasons.push(block('forbidden', `Start-Process : « ${program} » est un interpréteur ou un script, interdit même par ce détour.`));
+            }
+        if (boundParam(cmd, ['Verb']).length > 0)
+            draft.reasons.push(warn('elevation', 'Start-Process -Verb peut demander une élévation de privilèges.'));
+    }
+    if (boundParam(cmd, ['InFile', 'Body', 'Form']).length > 0)
+        draft.reasons.push(warn('web-upload', `${label} envoie des données ou un fichier au serveur.`));
+    const method = constants(boundParam(cmd, ['Method'])[0]?.el);
+    if (method && method.some((m) => !/^(get|head|options|default)$/i.test(m)))
+        draft.reasons.push(warn('web-method', `${label} : la méthode ${method.join(', ')} envoie ou modifie des données sur le serveur.`));
+}
+function evaluateCommand(cmd, ctx, draft) {
+    const kind = (['Cmdlet', 'Function', 'Application', 'ExternalScript', 'Alias', 'NotFound', 'Dynamic'].includes(cmd.kind) ? cmd.kind : 'Other');
+    const finding = { name: cmd.name ?? cmd.text.slice(0, 60), resolved: cmd.resolved, kind, source: cmd.source, level: 'denied', note: '' };
+    const refuse = (code, message, note, hard = false, extra = {}) => {
+        draft.reasons.push({ ...(hard ? floor(code, message) : block(code, message)), ...extra });
+        return { ...finding, note };
+    };
+    if (!cmd.name)
+        return refuse('dynamic-command', `Commande calculée à l’exécution (« ${cmd.text.slice(0, 80)} ») : elle ne peut pas être vérifiée.`, 'commande dynamique');
+    const label = cmd.resolved ?? cmd.name;
+    if (cmd.op === 'Dot')
+        return refuse('dot-source', `« ${cmd.name} » : le chargement de script (point-source) est refusé.`, 'script chargé');
+    if (/[\\/]/.test(cmd.name) || kind === 'ExternalScript')
+        return refuse('path-invocation', `« ${cmd.name} » : lancer un programme ou un script par son chemin est refusé.`, 'programme désigné par chemin');
+    if (kind === 'NotFound')
+        return refuse('not-found', `« ${cmd.name} » n’est ni installé sur cette machine ni une commande PowerShell.`, 'introuvable');
+    if (kind === 'Other' || kind === 'Alias')
+        return refuse('not-allowlisted', `« ${cmd.name} » : type de commande non pris en charge.`, 'hors liste blanche');
+    const isApp = kind === 'Application';
+    const { key, ext } = isApp ? appKey(cmd.source ?? cmd.resolved ?? cmd.name) : { key: label.toLowerCase(), ext: '' };
+    if (isApp && SCRIPT_HOST_EXTENSIONS.has(ext))
+        return refuse('script-host', `« ${cmd.name} » est un script (${ext}) : il lancerait un interpréteur.`, 'script');
+    const rule = isApp ? APPS.get(key) : CMDLETS.get(key);
+    const custom = ctx.custom.find((c) => c.name.toLowerCase() === key);
+    const unlocked = ctx.unlocked.some((u) => u.toLowerCase() === key);
+    if (rule?.level === 'forbidden')
+        return refuse('forbidden', `${label} est interdit : ${rule.note ?? rule.category}.`, `interdit · ${rule.category}`, FLOOR_CATEGORIES.has(rule.category));
+    if (rule?.level === 'destructive' && !unlocked)
+        return refuse('destructive', `${label} est une commande destructrice (${rule.note ?? rule.category}), refusée par défaut. Tu peux la débloquer dans Réglages › Liste blanche.`, `destructif · ${rule.category}`, true, { plain: `${label} est une commande destructrice (${rule.note ?? rule.category}), refusée par défaut.`, subject: key });
+    if (!rule && !custom)
+        return refuse('not-allowlisted', `${label} n’est pas dans la liste blanche. Tu peux l’ajouter dans Réglages › Liste blanche.`, 'hors liste blanche', false, { plain: `${label} n’est pas dans la liste blanche.`, subject: key });
+    let level = rule ? (rule.level === 'read' ? 'read' : 'sensitive') : custom?.level === 'read' ? 'read' : 'sensitive';
+    const before = draft.reasons.length;
+    const wasSensitive = draft.sensitive;
+    draft.sensitive = false;
+    if (rule?.level === 'destructive')
+        draft.reasons.push(warn('unlocked', `${label} est une commande destructrice que tu as débloquée : ${rule.note ?? ''}.`));
+    if (!rule && custom)
+        draft.reasons.push(info('custom', `${label} vient de ta liste blanche personnelle : ses arguments ne sont pas contrôlés.`));
+    if (cmd.alias && /^(curl|wget)$/i.test(cmd.name))
+        draft.reasons.push(warn('alias', `Dans PowerShell 5.1, « ${cmd.name} » est un alias d’Invoke-WebRequest. Pour le vrai curl, écris curl.exe.`));
+    if (isApp) {
+        const appRule = APPS.get(key);
+        if (appRule?.system && !isInside(cmd.source ?? '', `${ctx.systemRoot}\\System32`))
+            draft.reasons.push(block('app-location', `${cmd.name} : l’exécutable trouvé (${cmd.source ?? 'inconnu'}) n’est pas celui de Windows.`));
+        const argv = appArgv(cmd);
+        if (!argv)
+            draft.reasons.push(block('dynamic-args', `${cmd.name} : ses arguments doivent être des constantes pour être vérifiés.`));
+        else if (appRule?.args) {
+            const result = appRule.args(argv);
+            draft.reasons.push(...result.reasons);
+            if (result.level)
+                level = result.level;
+            if (result.needsUnlock) {
+                if (unlocked)
+                    draft.reasons.push(warn('unlocked', `${cmd.name} : ${result.needsUnlock} (commande que tu as débloquée).`));
+                else
+                    draft.reasons.push({ ...floor('destructive', `${cmd.name} : ${result.needsUnlock}, refusé par défaut. Tu peux débloquer « ${key} » dans Réglages › Liste blanche.`), plain: `${cmd.name} : ${result.needsUnlock}, refusé par défaut.`, subject: key });
+            }
+            for (const host of result.hosts ?? [])
+                draft.network.push(host);
+            for (const host of result.scanHosts ?? [])
+                checkScanHost(host, cmd.name, ctx, draft);
+            for (const file of result.writes ?? [])
+                checkWritePath(file, `${cmd.name} (fichier de sortie)`, ctx, draft);
+        }
+        if (argv?.some((a) => /^[\\/]{2}/.test(a)))
+            draft.reasons.push(floor('unc-path', `${cmd.name} : les chemins réseau sont refusés.`));
+    }
+    else if (rule) {
+        evaluateCmdlet(cmd, rule, label, ctx, draft);
+    }
+    else if (cmd.elements.some((el) => el.k === 'b')) {
+        draft.reasons.push(block('scriptblock-arg', `${label} : cette commande ne doit pas recevoir de bloc de script.`));
+    }
+    if (draft.sensitive)
+        level = 'sensitive';
+    draft.sensitive = wasSensitive || level === 'sensitive';
+    if (draft.reasons.slice(before).some((r) => r.severity === 'block'))
+        level = 'denied';
+    const note = rule ? `${rule.category}${rule.note ? ` · ${rule.note}` : ''}` : 'liste personnelle';
+    return { ...finding, level, note };
+}
+export function evaluate(analysis, ctx) {
+    const draft = { reasons: [], writes: [], network: [], sensitive: false };
+    if (!analysis.ok) {
+        const first = analysis.errors[0] ?? 'erreur inconnue';
+        draft.reasons.push(floor('syntax', `Erreur de syntaxe PowerShell : ${first}`));
+        return { level: 'denied', reasons: draft.reasons, commands: [], writes: [], network: [] };
+    }
+    for (const node of analysis.nodes) {
+        if (!ALLOWED_NODES.has(node))
+            draft.reasons.push(block('construct', `Construction non autorisée : ${NODE_LABELS[node] ?? node}.`));
+    }
+    for (const type of analysis.types) {
+        if (!SAFE_TYPES.has(normType(type)))
+            draft.reasons.push(block('type', `Le type [${type}] n’est pas autorisé : seuls les types de base le sont.`));
+    }
+    for (const m of analysis.members) {
+        const member = m.member?.toLowerCase() ?? null;
+        if (m.static) {
+            const allowed = m.type ? STATIC_MEMBERS[normType(m.type)] : undefined;
+            if (!member || !allowed || (allowed !== '*' && !allowed.has(member)))
+                draft.reasons.push(block('static-member', `L’accès statique [${m.type ?? '?'}]::${m.member ?? '?'} n’est pas autorisé.`));
+        }
+        else if (m.call && (!member || !INSTANCE_METHODS.has(member))) {
+            draft.reasons.push(block('method-call', `L’appel de méthode .${m.member ?? '(calculée)'}() n’est pas autorisé : il échapperait à la liste blanche.`));
+        }
+    }
+    for (const v of analysis.variables) {
+        const name = v.name.toLowerCase();
+        const drive = v.drive?.toLowerCase() ?? null;
+        if (FORBIDDEN_VARIABLES.has(name))
+            draft.reasons.push(block('variable', `La variable $${v.name} est réservée au moteur.`));
+        else if (drive === 'env') {
+            if (v.assigned)
+                draft.reasons.push(block('env-assign', `Modifier $${v.name} est refusé : cela pourrait changer le programme réellement lancé.`));
+        }
+        else if (drive !== null && !VARIABLE_SCOPES.has(drive)) {
+            draft.reasons.push(block('drive-variable', `La variable \${${v.name}} lit ou écrit directement dans un lecteur PowerShell : refusé.`));
+        }
+    }
+    // « (Get-Item x).IsReadOnly = $true » modifie un fichier sans passer par une commande d'écriture.
+    if (analysis.assignTargets.length > 0)
+        draft.reasons.push(block('member-assign', 'Affecter une propriété ou un élément d’objet est refusé : cela peut modifier le système sans passer par une commande contrôlée.'));
+    for (const r of analysis.redirections) {
+        const target = r.target;
+        if (target.k === 'v' && target.n?.toLowerCase() === 'null')
+            continue;
+        const values = constants(target);
+        if (!values) {
+            draft.reasons.push(block('dynamic-path', 'Redirection vers un fichier calculé : le chemin ne peut pas être vérifié.'));
+            continue;
+        }
+        draft.sensitive = true;
+        for (const v of values)
+            checkWritePath(v, 'Redirection', ctx, draft);
+    }
+    const commands = analysis.commands.map((cmd) => evaluateCommand(cmd, ctx, draft));
+    const seen = new Set();
+    const reasons = draft.reasons.filter((r) => {
+        const key = `${r.code}|${r.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    const blocked = reasons.some((r) => r.severity === 'block');
+    const level = blocked ? 'denied' : draft.sensitive || commands.some((c) => c.level === 'sensitive') ? 'sensitive' : 'read';
+    return { level, reasons, commands, writes: [...new Set(draft.writes)], network: [...new Set(draft.network)] };
+}
+/** Modules à charger avant de passer en mode contraint (les modules de fonctions ne s'y chargent pas seuls). */
+export function modulesToPreload(analysis) {
+    const names = new Set();
+    for (const cmd of analysis.commands) {
+        if (cmd.kind === 'Function' && cmd.module && /^[A-Za-z0-9._-]{1,80}$/.test(cmd.module))
+            names.add(cmd.module);
+    }
+    return [...names];
+}

package/lib/server/engine/relax.js

@@ -0,0 +1,10 @@
+export const isPolicyMode = (value) => value === 'stricte' || value === 'souple';
+export function decide(verdict, mode) {
+    const blocks = verdict.reasons.filter((r) => r.severity === 'block');
+    if (blocks.length === 0)
+        return { outcome: verdict.level === 'read' ? 'read' : 'sensitive', blocking: [] };
+    if (mode === 'stricte')
+        return { outcome: 'refused', blocking: blocks };
+    const floors = blocks.filter((r) => r.floor === true);
+    return floors.length > 0 ? { outcome: 'refused', blocking: floors } : { outcome: 'outside', blocking: [] };
+}

package/lib/server/engine/runner.js

@@ -0,0 +1,193 @@
+/**
+ * Exécution réelle d'une commande PowerShell déjà validée par la politique.
+ *
+ * Le script complet (préambule, commande, épilogue) est transmis par l'entrée standard, encodé en
+ * base64 : ni fichier temporaire, ni contournement de la politique d'exécution, ni citation à échapper.
+ */
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { createErrorTidier, createLineDecoder } from './decoder.js';
+/** PATH de l'exécution : les dossiers de Windows d'abord, pour qu'un « whoami » soit bien celui de Windows. */
+export function engineEnv(base) {
+    const root = base.SystemRoot ?? base.windir ?? 'C:\\Windows';
+    const current = base.PATH ?? base.Path ?? '';
+    const head = [`${root}\\System32`, root, `${root}\\System32\\Wbem`, `${root}\\System32\\WindowsPowerShell\\v1.0`];
+    const env = { ...base };
+    delete env.Path;
+    env.PATH = [...head, ...current.split(';').filter((p) => p && !head.some((h) => h.toLowerCase() === p.toLowerCase()))].join(';');
+    return env;
+}
+const b64 = (s) => Buffer.from(s, 'utf8').toString('base64');
+/** Ligne unique envoyée sur l'entrée standard : décode le script puis l'exécute. */
+const bootstrap = (script) => `& ([scriptblock]::Create([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${b64(script)}'))))\n`;
+export function buildScript(request) {
+    const imports = request.modules.filter((m) => /^[A-Za-z0-9._-]{1,80}$/.test(m)).map((m) => `Import-Module -Name '${m}' -ErrorAction SilentlyContinue`);
+    return [
+        `$ProgressPreference = 'SilentlyContinue'`,
+        `$OutputEncoding = [Console]::OutputEncoding`,
+        ...imports,
+        ...(request.constrained ? [`$ExecutionContext.SessionState.LanguageMode = 'ConstrainedLanguage'`] : []),
+        request.command,
+        // Le code de sortie est seulement noté ici. « exit » n'est appelé qu'après la fin du bloc (voir runLines) :
+        // appelé dans le bloc, il couperait les tableaux que PowerShell met en forme à la fin du pipeline.
+        `$__ok = $?; $__code = $LASTEXITCODE`,
+        `$global:__prm_exit = 0`,
+        `if (-not $__ok) { if ($__code) { $global:__prm_exit = $__code } else { $global:__prm_exit = 1 } }`,
+    ].join('\n');
+}
+/** Lignes envoyées à PowerShell : le bloc, puis la sortie avec le code noté par le bloc. */
+const runLines = (script) => `${bootstrap(script)}exit $global:__prm_exit\n`;
+const POWERSHELL_ARGS = ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '-'];
+function killTree(pid, env) {
+    if (pid === undefined)
+        return;
+    if (process.platform === 'win32') {
+        const root = env.SystemRoot ?? 'C:\\Windows';
+        spawn(path.win32.join(root, 'System32', 'taskkill.exe'), ['/PID', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' }).on('error', () => undefined);
+    }
+    else {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            /* déjà terminé */
+        }
+    }
+}
+export class PowerShellRunner {
+    env;
+    oemTable;
+    executable;
+    constructor(options) {
+        this.env = options.env;
+        this.oemTable = options.oemTable;
+        this.executable = options.executable ?? 'powershell.exe';
+    }
+    run(request) {
+        const queue = [];
+        let wake = null;
+        let finished = false;
+        const push = (event) => {
+            queue.push(event);
+            wake?.();
+            wake = null;
+        };
+        const started = Date.now();
+        let cancelled = false;
+        let timedOut = false;
+        let truncated = false;
+        let bytes = 0;
+        const child = spawn(this.executable, POWERSHELL_ARGS, { cwd: request.cwd, env: this.env, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+        const stop = () => killTree(child.pid, this.env);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            stop();
+        }, request.timeoutMs);
+        const tidy = createErrorTidier();
+        const wire = (stream, source) => {
+            const decoder = createLineDecoder(this.oemTable);
+            let partial = null;
+            const emit = (text) => {
+                if (!text || truncated)
+                    return;
+                const shown = stream === 'stderr' ? tidy(text) : text;
+                if (shown)
+                    push({ type: 'out', stream, text: shown });
+            };
+            source.on('data', (chunk) => {
+                bytes += chunk.length;
+                if (bytes > request.maxBytes && !truncated) {
+                    emit(decoder.push(chunk));
+                    truncated = true;
+                    stop();
+                    return;
+                }
+                emit(decoder.push(chunk));
+                // Une invite ou une barre de progression n'a pas de fin de ligne : on la montre après un court délai.
+                if (partial)
+                    clearTimeout(partial);
+                partial = setTimeout(() => emit(decoder.flush()), 120);
+            });
+            source.on('end', () => {
+                if (partial)
+                    clearTimeout(partial);
+                emit(decoder.flush());
+            });
+        };
+        wire('stdout', child.stdout);
+        wire('stderr', child.stderr);
+        const end = (exitCode) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            push({ type: 'end', exitCode: cancelled || timedOut ? null : exitCode, durationMs: Date.now() - started, cancelled, timedOut, truncated });
+        };
+        child.on('error', (err) => {
+            push({ type: 'out', stream: 'stderr', text: `PowerShell n’a pas pu démarrer : ${err.message}\n` });
+            end(null);
+        });
+        child.on('close', (code) => end(code));
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(runLines(buildScript(request)));
+        const events = {
+            [Symbol.asyncIterator]: () => ({
+                next: async () => {
+                    for (;;) {
+                        const event = queue.shift();
+                        if (event)
+                            return { value: event, done: false };
+                        if (finished)
+                            return { value: undefined, done: true };
+                        await new Promise((resolve) => {
+                            wake = resolve;
+                        });
+                    }
+                },
+            }),
+        };
+        return {
+            events,
+            cancel: () => {
+                if (finished)
+                    return;
+                cancelled = true;
+                stop();
+            },
+        };
+    }
+}
+/** Interroge PowerShell une fois au démarrage : version, page de codes, table de décodage OEM. */
+export function probePowerShell(env, executable = 'powershell.exe', timeoutMs = 20_000) {
+    const script = [
+        `$t = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes([Console]::OutputEncoding.GetString([byte[]](128..255))))`,
+        `[Console]::Out.WriteLine('PRM|' + $PSVersionTable.PSVersion.ToString() + '|' + [Console]::OutputEncoding.CodePage + '|' + $t)`,
+    ].join('\n');
+    return new Promise((resolve) => {
+        const fail = (error) => resolve({ available: false, version: null, codePage: null, oemTable: null, error });
+        let out = '';
+        const child = spawn(executable, POWERSHELL_ARGS, { env, windowsHide: true, stdio: ['pipe', 'pipe', 'ignore'] });
+        const timer = setTimeout(() => {
+            child.kill();
+            fail('PowerShell ne répond pas.');
+        }, timeoutMs);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            fail(`PowerShell est introuvable (${err.message}).`);
+        });
+        child.stdout.on('data', (chunk) => {
+            out += chunk.toString('latin1');
+        });
+        child.on('close', () => {
+            clearTimeout(timer);
+            const line = out.split(/\r?\n/).find((l) => l.startsWith('PRM|'));
+            const [, version, codePage, table] = line?.split('|') ?? [];
+            if (!version || !codePage || !table)
+                return fail('Réponse inattendue de PowerShell.');
+            const oemTable = Buffer.from(table, 'base64').toString('utf8');
+            resolve({ available: true, version, codePage: Number(codePage), oemTable: oemTable.length === 128 ? oemTable : null, error: null });
+        });
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(bootstrap(script));
+    });
+}

package/lib/server/errors.js

@@ -0,0 +1,23 @@
+/** Erreur applicative : un code stable, un statut HTTP, un message lisible par l'utilisateur. */
+export class AppError extends Error {
+    code;
+    status;
+    constructor(code, status, message) {
+        super(message);
+        this.name = 'AppError';
+        this.code = code;
+        this.status = status;
+    }
+}
+export const badRequest = (message, code = 'bad_request') => new AppError(code, 400, message);
+export const notFound = (message) => new AppError('not_found', 404, message);
+export const forbidden = (message, code = 'forbidden') => new AppError(code, 403, message);
+/** Ramène n'importe quelle erreur à un couple code + message sûr à afficher. */
+export function describeError(err) {
+    if (err instanceof AppError)
+        return { code: err.code, message: err.message, status: err.status };
+    if (err instanceof Error && err.name === 'AbortError')
+        return { code: 'aborted', message: 'Opération interrompue.', status: 499 };
+    const message = err instanceof Error ? err.message : String(err);
+    return { code: 'internal', message: `Erreur interne : ${message}`, status: 500 };
+}