@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/cli/bridge.js

@@ -0,0 +1,292 @@
+/**
+ * Cœur du pont entre la TUI « prmt » et le moteur de politique de la console.
+ *
+ * La TUI pose une question par ligne (JSON), le pont répond par ligne. Il n'exécute jamais rien :
+ * il analyse une commande, rend un verdict, et tient à jour la liste blanche et le périmètre que
+ * les deux interfaces partagent.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { scopeInput } from '../../shared/schemas.js';
+import { APPS, CMDLETS, appKey } from '../engine/catalog.js';
+import { existingDirectory, hostInScope, isInside, mentionedHosts } from '../engine/paths.js';
+import { evaluate, modulesToPreload } from '../engine/policy.js';
+import { decide, isPolicyMode } from '../engine/relax.js';
+export class BridgeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const MAX_COMMAND = 4000;
+const MAX_SCRIPT = 256 * 1024;
+/** Toutes les constantes d'une commande, quel que soit leur niveau (paramètres, listes). */
+function constants(elements) {
+    const out = [];
+    for (const el of elements) {
+        if ((el.k === 's' || el.k === 'n' || el.k === 'x') && el.v)
+            out.push(el.v);
+        if (el.a)
+            out.push(...constants([el.a]));
+        if (el.i)
+            out.push(...constants(el.i));
+    }
+    return out;
+}
+/** Machines citées en clair dans les arguments d'une commande (adresses IPv4, hôtes d'URL). */
+export function explicitTargets(analysis) {
+    const hosts = new Set();
+    for (const cmd of analysis.commands) {
+        for (const value of [cmd.name ?? '', ...constants(cmd.elements)])
+            for (const host of mentionedHosts(value))
+                hosts.add(host);
+    }
+    return [...hosts];
+}
+/**
+ * Script PowerShell que la commande lance par son chemin : « .\\scan.ps1 », « & C:\\x\\scan.ps1 »,
+ * « powershell -File scan.ps1 ». Renvoie le chemin tel qu'il est écrit, ou null.
+ */
+export function scriptPath(analysis) {
+    if (!analysis.ok || analysis.commands.length !== 1)
+        return null;
+    const cmd = analysis.commands[0];
+    if (!cmd?.name)
+        return null;
+    if (/\.ps1$/i.test(cmd.name))
+        return cmd.name;
+    if (!/^(?:powershell|pwsh)(?:\.exe)?$/i.test(cmd.name))
+        return null;
+    const values = cmd.elements.filter((el) => el.k === 's' && typeof el.v === 'string').map((el) => el.v ?? '');
+    return values.find((v) => /\.ps1$/i.test(v)) ?? null;
+}
+const CD_NODES = new Set(['ScriptBlockAst', 'NamedBlockAst', 'PipelineAst', 'CommandAst', 'CommandParameterAst', 'StringConstantExpressionAst']);
+const text = (value, name) => {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new BridgeError('bad_request', `Champ « ${name} » manquant.`);
+    return value;
+};
+const names = (value) => {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20)
+        throw new BridgeError('bad_request', 'Champ « names » : une liste de 1 à 20 noms est attendue.');
+    return value.map((v) => text(v, 'names').trim());
+};
+/**
+ * « cd dossier » (ou « D: ») seul sur sa ligne : renvoie le dossier demandé, sinon null.
+ * Dans une commande composée, Set-Location reste interdit : les chemins relatifs qui suivent ne seraient plus vérifiables.
+ */
+export function soleCd(analysis) {
+    if (!analysis.ok || analysis.commands.length !== 1)
+        return null;
+    if (analysis.redirections.length + analysis.variables.length + analysis.members.length + analysis.types.length + analysis.assignTargets.length > 0)
+        return null;
+    if (analysis.nodes.some((node) => !CD_NODES.has(node)))
+        return null;
+    const cmd = analysis.commands[0];
+    if (!cmd || cmd.bindErrors.length > 0)
+        return null;
+    if (cmd.kind === 'Function' && /^[A-Za-z]:$/.test(cmd.name ?? '') && cmd.elements.length <= 1)
+        return `${(cmd.name ?? '').toUpperCase()}\\`;
+    if ((cmd.resolved ?? '').toLowerCase() !== 'set-location' || cmd.bound.length !== 1)
+        return null;
+    const bound = cmd.bound[0];
+    if (!bound || !['path', 'literalpath'].includes(bound.name.toLowerCase()))
+        return null;
+    return bound.el?.k === 's' && bound.el.v ? bound.el.v : null;
+}
+export class Bridge {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    summary() {
+        const s = this.deps.settings.get();
+        const counts = { read: 0, sensitive: 0, destructive: 0, forbidden: 0 };
+        for (const rule of [...CMDLETS.values(), ...APPS.values()])
+            counts[rule.level]++;
+        return {
+            counts,
+            constrained: s.engine.constrainedLanguage,
+            custom: s.allowlist.custom,
+            unlocked: s.allowlist.unlocked,
+            roots: s.engine.roots,
+            targets: this.deps.scope.list().map((t) => ({ host: t.host, includeSubdomains: t.includeSubdomains, note: t.note, attestedAt: t.attestedAt })),
+            dataDir: this.deps.dataDir,
+        };
+    }
+    async verdict(command, cwd, mode) {
+        if (command.length > MAX_COMMAND)
+            throw new BridgeError('too_long', `Commande trop longue (${command.length} caractères, ${MAX_COMMAND} au plus).`);
+        const { settings, scope, home, systemRoot, analyzer } = this.deps;
+        const s = settings.get();
+        const dir = cwd && cwd.trim() ? cwd : (s.engine.roots[0] ?? home);
+        const analysis = await analyzer.analyze(command.trim());
+        const target = soleCd(analysis);
+        if (target !== null) {
+            const cmd = analysis.commands[0];
+            const finding = { name: cmd?.name ?? 'cd', resolved: 'Set-Location', kind: 'Cmdlet', source: null, level: 'read', note: 'dossier courant' };
+            const found = existingDirectory(dir, target, home);
+            if (!found.ok) {
+                const reason = { code: 'bad-cwd', message: found.message, severity: 'block', floor: true };
+                return { level: 'denied', reasons: [reason], commands: [{ ...finding, level: 'denied' }], writes: [], network: [], outcome: 'refused', mode, blocking: [reason], modules: [], constrained: false };
+            }
+            const reasons = [{ code: 'cd', message: `Change le dossier courant : ${found.cwd}`, severity: 'info' }];
+            if (!s.engine.roots.some((root) => isInside(found.cwd, root)))
+                reasons.push({ code: 'cd-outside', message: 'Ce dossier est en dehors de tes dossiers autorisés : les écritures y seront refusées.', severity: 'info' });
+            return { level: 'read', reasons, commands: [finding], writes: [], network: [], outcome: 'read', mode, blocking: [], modules: [], constrained: s.engine.constrainedLanguage, cd: found.cwd };
+        }
+        const ctx = { cwd: dir, roots: s.engine.roots, home, custom: s.allowlist.custom, unlocked: s.allowlist.unlocked, targets: scope.list(), systemRoot };
+        const verdict = evaluate(analysis, ctx);
+        const decision = decide(verdict, mode);
+        const result = { ...verdict, ...decision, mode, modules: modulesToPreload(analysis), constrained: s.engine.constrainedLanguage && decision.outcome !== 'outside' };
+        if (decision.outcome !== 'outside')
+            return result;
+        // Hors politique (mode souple) : l'analyse ne sait pas ce que fait la commande. Deux contrôles restent possibles.
+        // 1. Une machine citée en clair dans ses arguments doit être dans le périmètre.
+        const foreign = explicitTargets(analysis).filter((host) => !hostInScope(host, scope.list()));
+        if (foreign.length > 0) {
+            const blocking = foreign.map((host) => ({
+                code: 'target-out-of-scope',
+                severity: 'block',
+                floor: true,
+                subject: host,
+                message: `« ${host} » n’est pas dans ton périmètre autorisé, et cette commande n’est pas analysable : elle est refusée.`,
+                plain: `« ${host} » n’est pas dans ton périmètre autorisé, et cette commande n’est pas analysable : elle est refusée.`,
+            }));
+            return { ...result, outcome: 'refused', blocking, reasons: [...verdict.reasons, ...blocking], network: [...new Set([...verdict.network, ...foreign])] };
+        }
+        // 2. Un script PowerShell lancé par son chemin : son contenu, lui, s'analyse.
+        const script = scriptPath(analysis);
+        if (script)
+            return this.withScript(result, script, dir, mode, ctx);
+        return result;
+    }
+    /** Analyse le contenu d'un script .ps1 : ses planchers refusent la commande, le reste s'ajoute à ce que tu lis avant de valider. */
+    async withScript(outer, script, dir, mode, ctx) {
+        const file = path.win32.resolve(dir, script.replace(/^~(?=[\\/])/, this.deps.home));
+        const name = path.win32.basename(file);
+        const note = (message) => ({ ...outer, reasons: [...outer.reasons, { code: 'script', message, severity: 'warn' }] });
+        let content;
+        try {
+            if (/^[\\/]{2}/.test(file))
+                return outer;
+            if (fs.statSync(file).size > MAX_SCRIPT)
+                return note(`${name} est trop long pour être analysé : son contenu n’est pas contrôlé.`);
+            content = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '').trim();
+        }
+        catch {
+            return note(`${name} est introuvable ou illisible : son contenu n’est pas contrôlé.`);
+        }
+        if (!content)
+            return outer;
+        const inner = evaluate(await this.deps.analyzer.analyze(content), ctx);
+        const floors = decide(inner, mode).blocking;
+        if (floors.length > 0) {
+            const blocking = floors.map((r) => ({ ...r, message: `Dans ${name} : ${r.plain ?? r.message}`, plain: `Dans ${name} : ${r.plain ?? r.message}` }));
+            return { ...outer, outcome: 'refused', blocking, reasons: [...outer.reasons, ...blocking], writes: inner.writes, network: inner.network };
+        }
+        return {
+            ...note(`Contenu de ${name} analysé : aucune commande destructrice verrouillée ni cible hors périmètre.`),
+            writes: [...new Set([...outer.writes, ...inner.writes])],
+            network: [...new Set([...outer.network, ...inner.network])],
+        };
+    }
+    /** Autorise des commandes : débloque une destructrice, ou ajoute une commande absente de la liste. Les interdites le restent. */
+    allow(list) {
+        const s = this.deps.settings.get();
+        const custom = [...s.allowlist.custom];
+        const unlocked = [...s.allowlist.unlocked];
+        const result = { added: [], unlocked: [], already: [], refused: [] };
+        for (const raw of list) {
+            if (!/^[A-Za-z][\w.-]{0,63}$/.test(raw)) {
+                result.refused.push({ name: raw, reason: 'nom de commande invalide' });
+                continue;
+            }
+            const lower = raw.toLowerCase();
+            const key = appKey(raw).key;
+            const cmdlet = CMDLETS.get(lower);
+            const app = cmdlet ? undefined : APPS.get(key);
+            const rule = cmdlet ?? app;
+            const id = cmdlet ? lower : key;
+            if (rule?.level === 'forbidden')
+                result.refused.push({ name: raw, reason: `interdite (${rule.note ?? rule.category})` });
+            else if (rule?.level === 'destructive' || app?.unlockable) {
+                if (unlocked.includes(id))
+                    result.already.push(raw);
+                else {
+                    unlocked.push(id);
+                    result.unlocked.push(raw);
+                }
+            }
+            else if (rule || custom.some((c) => c.name.toLowerCase() === id))
+                result.already.push(raw);
+            else if (custom.length >= 60)
+                result.refused.push({ name: raw, reason: 'la liste personnelle est limitée à 60 commandes' });
+            else {
+                custom.push({ name: id, level: 'sensitive' });
+                result.added.push(raw);
+            }
+        }
+        if (result.added.length + result.unlocked.length > 0) {
+            this.deps.settings.patch({ allowlist: { custom, unlocked } });
+            this.deps.journal.add({
+                kind: 'settings',
+                outcome: 'info',
+                title: `Liste blanche modifiée depuis la TUI : ${[...result.added, ...result.unlocked].join(', ')}`,
+                data: { origin: 'tui', added: result.added, unlocked: result.unlocked },
+            });
+        }
+        return result;
+    }
+    revoke(list) {
+        const s = this.deps.settings.get();
+        const wanted = new Set(list.flatMap((n) => [n.toLowerCase(), appKey(n).key]));
+        const custom = s.allowlist.custom.filter((c) => !wanted.has(c.name.toLowerCase()));
+        const unlocked = s.allowlist.unlocked.filter((u) => !wanted.has(u.toLowerCase()));
+        const removed = [...s.allowlist.custom.map((c) => c.name), ...s.allowlist.unlocked].filter((n) => wanted.has(n.toLowerCase()));
+        if (removed.length > 0) {
+            this.deps.settings.patch({ allowlist: { custom, unlocked } });
+            this.deps.journal.add({ kind: 'settings', outcome: 'info', title: `Autorisation retirée depuis la TUI : ${removed.join(', ')}`, data: { origin: 'tui', removed } });
+        }
+        return { removed };
+    }
+    async handle(req) {
+        const { scope, journal } = this.deps;
+        switch (req.op) {
+            case 'verdict':
+                return this.verdict(text(req.command, 'command'), typeof req.cwd === 'string' ? req.cwd : null, isPolicyMode(req.mode) ? req.mode : 'stricte');
+            case 'politique':
+                return this.summary();
+            case 'autoriser':
+                return { ...this.allow(names(req.names)), policy: this.summary() };
+            case 'retirer':
+                return { ...this.revoke(names(req.names)), policy: this.summary() };
+            case 'cible-ajouter': {
+                const parsed = scopeInput.safeParse({ host: req.host, note: typeof req.note === 'string' ? req.note : '', includeSubdomains: req.includeSubdomains === true, attest: req.attest });
+                if (!parsed.success)
+                    throw new BridgeError('bad_request', parsed.error.issues[0]?.message ?? 'Cible invalide.');
+                const target = scope.add(parsed.data);
+                journal.add({
+                    kind: 'scope',
+                    outcome: 'info',
+                    title: `Cible ajoutée au périmètre depuis la TUI : ${target.host}`,
+                    detail: 'Attestation : la cible t’appartient ou tu as une autorisation écrite.',
+                    data: { origin: 'tui', host: target.host, includeSubdomains: target.includeSubdomains, note: target.note },
+                });
+                return { added: target.host, policy: this.summary() };
+            }
+            case 'cible-retirer': {
+                const host = text(req.host, 'host').trim().toLowerCase();
+                const target = scope.list().find((t) => t.host === host);
+                if (!target)
+                    throw new BridgeError('not_found', `« ${host} » n’est pas dans le périmètre.`);
+                scope.remove(target.id);
+                journal.add({ kind: 'scope', outcome: 'info', title: `Cible retirée du périmètre depuis la TUI : ${host}`, data: { origin: 'tui', host } });
+                return { removed: host, policy: this.summary() };
+            }
+            default:
+                throw new BridgeError('unknown_op', `Opération inconnue : ${String(req.op)}`);
+        }
+    }
+}

package/lib/server/cli/pont.js

@@ -0,0 +1,62 @@
+/**
+ * Pont entre la TUI « prmt » (Python) et le moteur de politique de la console.
+ *
+ * La TUI lance ce programme et lui parle en JSON, une demande par ligne sur l'entrée standard,
+ * une réponse par ligne sur la sortie standard. Les deux interfaces partagent ainsi la même
+ * liste blanche, le même périmètre et les mêmes réglages, sans que le serveur web ait besoin de tourner.
+ *
+ *   {"id":1,"op":"verdict","command":"Get-Date","cwd":"C:\\Users\\moi","mode":"stricte"}
+ *   {"id":1,"ok":true,"result":{"level":"read","outcome":"read","reasons":[],…}}
+ *
+ * Opérations : verdict, politique, autoriser, retirer, cible-ajouter, cible-retirer.
+ * Ce programme n'exécute jamais la commande : il l'analyse et rend un verdict.
+ */
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { VERSION, defaultSettings, loadConfig } from '../config.js';
+import { PowerShellAnalyzer } from '../engine/analyzer.js';
+import { engineEnv } from '../engine/runner.js';
+import { describeError } from '../errors.js';
+import { Journal } from '../journal.js';
+import { ScopeStore, SettingsStore } from '../stores.js';
+import { Bridge, BridgeError } from './bridge.js';
+const config = loadConfig();
+const analyzer = new PowerShellAnalyzer({ env: engineEnv(process.env), cwd: os.tmpdir() });
+const bridge = new Bridge({
+    analyzer,
+    settings: new SettingsStore(path.join(config.dataDir, 'reglages.json'), defaultSettings(config)),
+    scope: new ScopeStore(path.join(config.dataDir, 'perimetre.json')),
+    journal: new Journal(path.join(config.dataDir, 'journal.jsonl')),
+    home: config.home,
+    systemRoot: config.systemRoot,
+    dataDir: config.dataDir,
+});
+const send = (message) => void process.stdout.write(`${JSON.stringify(message)}\n`);
+send({ ready: true, version: VERSION, dataDir: config.dataDir });
+const lines = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+lines.on('line', (line) => {
+    if (!line.trim())
+        return;
+    let req;
+    try {
+        req = JSON.parse(line);
+    }
+    catch {
+        send({ id: null, ok: false, error: { code: 'bad_json', message: 'Demande illisible.' } });
+        return;
+    }
+    const id = typeof req.id === 'string' || typeof req.id === 'number' ? req.id : null;
+    bridge.handle(req).then((result) => send({ id, ok: true, result }), (err) => {
+        if (err instanceof BridgeError)
+            send({ id, ok: false, error: { code: err.code, message: err.message } });
+        else {
+            const described = describeError(err);
+            send({ id, ok: false, error: { code: described.code, message: described.code === 'internal' && err instanceof Error ? err.message : described.message } });
+        }
+    });
+});
+lines.on('close', () => {
+    analyzer.dispose();
+    process.exit(0);
+});

package/lib/server/config.js

@@ -0,0 +1,68 @@
+/** Configuration du serveur local : ports, dossiers, valeurs par défaut. */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const VERSION = '2.0.0';
+/**
+ * La racine du paquet, où vivent dist/ et searxng/. On remonte jusqu'au package.json, pour que ça marche aussi bien depuis la
+ * source (server/) que depuis le JS compilé (lib/server/), car la profondeur n'est pas la même.
+ */
+function findRoot() {
+    let dir = import.meta.dirname;
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const up = path.dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    return path.resolve(import.meta.dirname, '..');
+}
+export const PACKAGE_ROOT = findRoot();
+/** SearXNG tel que l'installe « npm run searxng » : publié sur la boucle locale seulement. */
+export const DEFAULT_SEARXNG_URL = 'http://127.0.0.1:8888';
+/** Même règle que la TUI : OLLAMA_HOST, sinon 127.0.0.1:11434. */
+export function ollamaUrlFromEnv(env) {
+    let host = (env.OLLAMA_HOST ?? '').trim() || '127.0.0.1:11434';
+    if (!host.includes('://'))
+        host = `http://${host}`;
+    host = host.replace('0.0.0.0', '127.0.0.1').replace(/\/+$/, '');
+    if ((host.match(/:/g) ?? []).length === 1)
+        host += ':11434';
+    return host;
+}
+export function loadConfig(env = process.env, overrides = {}) {
+    const root = PACKAGE_ROOT;
+    const home = os.homedir();
+    return {
+        host: '127.0.0.1',
+        port: Number(env.PROMETHEE_PORT) || 4317,
+        dataDir: env.PROMETHEE_DATA ? path.resolve(env.PROMETHEE_DATA) : path.join(root, 'data'),
+        distDir: path.join(root, 'dist'),
+        dev: env.PROMETHEE_DEV === '1',
+        home,
+        systemRoot: env.SystemRoot ?? env.windir ?? 'C:\\Windows',
+        tuiDir: env.PROMETHEE_TUI ? path.resolve(env.PROMETHEE_TUI) : path.join(home, 'Documents', 'Promethee'),
+        defaultOllamaUrl: ollamaUrlFromEnv(env),
+        searchEnabled: env.PROMETHEE_SEARCH !== '0',
+        phonePort: Number(env.PROMETHEE_PORT_TELEPHONE) || 4318,
+        phoneAddresses: env.PROMETHEE_TELEPHONE_ADRESSES
+            ? env.PROMETHEE_TELEPHONE_ADRESSES.split(',')
+                .map((a) => a.trim())
+                .filter((a) => /^\d{1,3}(\.\d{1,3}){3}$/.test(a))
+            : null,
+        ...overrides,
+    };
+}
+export function defaultSettings(config) {
+    return {
+        model: null,
+        engine: { timeoutSec: 120, constrainedLanguage: true, confirmRead: true, roots: [config.home] },
+        allowlist: { custom: [], unlocked: [] },
+        ollama: { baseUrl: config.defaultOllamaUrl, replyTimeoutSec: 180 },
+        search: { enabled: config.searchEnabled, url: DEFAULT_SEARXNG_URL, learn: true },
+        fullCyber: false,
+        autoRun: false,
+    };
+}

package/lib/server/engine/analyzer.js

@@ -0,0 +1,205 @@
+/**
+ * Analyse d'une commande par le vrai parseur de PowerShell, sans l'exécuter.
+ *
+ * Un processus PowerShell reste ouvert et ne fait que deux choses : construire l'arbre
+ * syntaxique de la commande, et demander à Get-Command ce que chaque nom désigne.
+ * Le texte de la commande ne voyage qu'en base64 : il n'est jamais interprété ici.
+ */
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { analysisSchema } from '../../shared/analysis.js';
+import { AppError } from '../errors.js';
+const L = 'System.Management.Automation.Language.';
+/** Script d'analyse. Aucun accent grave ni « ${ » : il est écrit dans un gabarit brut. */
+export const ANALYZER_SCRIPT = String.raw `param($id, $b64)
+$r = [ordered]@{ ok = $true; errors = @(); nodes = @(); commands = @(); members = @(); types = @(); redirections = @(); variables = @(); assignTargets = @() }
+function PrmElem($e) {
+  if ($null -eq $e) { return $null }
+  $t = $e.GetType().Name
+  $raw = [string]$e.Extent.Text
+  if ($raw.Length -gt 400) { $raw = $raw.Substring(0, 400) }
+  switch ($t) {
+    'CommandParameterAst' {
+      $o = [ordered]@{ k = 'p'; n = [string]$e.ParameterName; t = $raw }
+      if ($e.Argument) { $o.a = PrmElem $e.Argument }
+      return $o }
+    'StringConstantExpressionAst' { return [ordered]@{ k = 's'; v = [string]$e.Value; t = $raw; bare = ($e.StringConstantType -eq 'BareWord') } }
+    'ConstantExpressionAst' { return [ordered]@{ k = 'n'; v = [string]$e.Value; t = $raw } }
+    'ExpandableStringExpressionAst' { return [ordered]@{ k = 'x'; t = $raw } }
+    'ScriptBlockExpressionAst' { return [ordered]@{ k = 'b' } }
+    'VariableExpressionAst' { return [ordered]@{ k = 'v'; n = [string]$e.VariablePath.UserPath; t = $raw; splat = [bool]$e.Splatted } }
+    'HashtableAst' { return [ordered]@{ k = 'h' } }
+    'ArrayLiteralAst' { return [ordered]@{ k = 'l'; t = $raw; i = @($e.Elements | ForEach-Object { PrmElem $_ }) } }
+    default { return [ordered]@{ k = 'e'; t = $t } }
+  }
+}
+try {
+  $src = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b64))
+  $tokens = $null; $errs = $null
+  $ast = [@L@Parser]::ParseInput($src, [ref]$tokens, [ref]$errs)
+  if ($errs.Count -gt 0) { $r.ok = $false; $r.errors = @($errs | ForEach-Object { [string]$_.Message }) }
+  else {
+    $all = @($ast.FindAll({ $true }, $true))
+    $r.nodes = @($all | ForEach-Object { $_.GetType().Name } | Sort-Object -Unique)
+    $assigned = @{}
+    foreach ($a in $all) {
+      if ($a -is [@L@AssignmentStatementAst]) {
+        foreach ($v in @($a.Left.FindAll({ $args[0] -is [@L@VariableExpressionAst] }, $true))) { $assigned[[string]$v.VariablePath.UserPath] = $true }
+        $left = $a.Left
+        while ($left -is [@L@AttributedExpressionAst]) { $left = $left.Child }
+        $targets = @($left)
+        if ($left -is [@L@ArrayLiteralAst]) { $targets = @($left.Elements) }
+        foreach ($t in $targets) {
+          $inner = $t
+          while ($inner -is [@L@AttributedExpressionAst]) { $inner = $inner.Child }
+          if ($inner -isnot [@L@VariableExpressionAst]) { $r.assignTargets += [string]$inner.GetType().Name }
+        }
+      }
+    }
+    foreach ($c in $all) {
+      if ($c -is [@L@CommandAst]) {
+        $name = $c.GetCommandName()
+        $o = [ordered]@{ name = $name; resolved = $null; kind = 'Dynamic'; source = $null; module = $null; alias = $false; op = [string]$c.InvocationOperator; text = [string]$c.Extent.Text; elements = @(); bound = @(); bindErrors = @() }
+        $info = $null
+        if ($name) {
+          $o.kind = 'NotFound'
+          $lookup = [System.Management.Automation.WildcardPattern]::Escape($name)
+          $info = Get-Command $lookup -ErrorAction SilentlyContinue | Select-Object -First 1
+          if ($info -and $info.CommandType -eq 'Alias') {
+            $o.alias = $true
+            $target = $info.ResolvedCommand
+            if (-not $target -and $info.Definition) { $target = Get-Command $info.Definition -ErrorAction SilentlyContinue | Select-Object -First 1 }
+            $info = $target
+          }
+          if ($info) {
+            $o.resolved = [string]$info.Name; $o.kind = [string]$info.CommandType
+            if ($info.CommandType -eq 'Application' -or $info.CommandType -eq 'ExternalScript') { $o.source = [string]$info.Source }
+            else { $o.module = [string]$info.ModuleName }
+          }
+        }
+        $els = @($c.CommandElements)
+        if ($els.Count -gt 1) { $o.elements = @($els[1..($els.Count - 1)] | ForEach-Object { PrmElem $_ }) }
+        if ($info -and ($info.CommandType -eq 'Cmdlet' -or $info.CommandType -eq 'Function')) {
+          try {
+            $b = [@L@StaticParameterBinder]::BindCommand($c, $true)
+            foreach ($k in @($b.BoundParameters.Keys)) { $o.bound += [ordered]@{ name = [string]$k; el = (PrmElem $b.BoundParameters[$k].Value) } }
+            foreach ($k in @($b.BindingExceptions.Keys)) { $o.bindErrors += ([string]$k + ' : ' + [string]$b.BindingExceptions[$k].BindingException.Message) }
+          } catch { $o.bindErrors += ('liaison : ' + [string]$_.Exception.Message) }
+        }
+        $r.commands += $o
+      }
+      elseif ($c -is [@L@MemberExpressionAst]) {
+        $member = $null
+        if ($c.Member -is [@L@StringConstantExpressionAst]) { $member = [string]$c.Member.Value }
+        $type = $null
+        if ($c.Expression -is [@L@TypeExpressionAst]) { $type = [string]$c.Expression.TypeName.FullName }
+        $r.members += [ordered]@{ member = $member; call = ($c -is [@L@InvokeMemberExpressionAst]); static = [bool]$c.Static; type = $type }
+      }
+      elseif ($c -is [@L@TypeExpressionAst]) { $r.types += [string]$c.TypeName.FullName }
+      elseif ($c -is [@L@ConvertExpressionAst]) { $r.types += [string]$c.Type.TypeName.FullName }
+      elseif ($c -is [@L@TypeConstraintAst]) { $r.types += [string]$c.TypeName.FullName }
+      elseif ($c -is [@L@FileRedirectionAst]) { $r.redirections += [ordered]@{ target = (PrmElem $c.Location); append = [bool]$c.Append; stream = [string]$c.FromStream } }
+      elseif ($c -is [@L@VariableExpressionAst]) {
+        $vp = $c.VariablePath
+        $drive = $null
+        if ($vp.IsDriveQualified) { $drive = [string]$vp.DriveName }
+        $r.variables += [ordered]@{ name = [string]$vp.UserPath; drive = $drive; assigned = $assigned.ContainsKey([string]$vp.UserPath); splat = [bool]$c.Splatted }
+      }
+    }
+    $r.types = @($r.types | Sort-Object -Unique)
+  }
+} catch { $r.ok = $false; $r.errors = @('ANALYSE ' + [string]$_.Exception.Message) }
+$json = $r | ConvertTo-Json -Depth 10 -Compress
+[Console]::Out.WriteLine('PRM|' + $id + '|' + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json)))
+`.replaceAll('@L@', L);
+const b64 = (s) => Buffer.from(s, 'utf8').toString('base64');
+/** Analyseur réel : garde un processus PowerShell ouvert, les demandes passent une par une. */
+export class PowerShellAnalyzer {
+    child = null;
+    buffer = '';
+    waiting = null;
+    chain = Promise.resolve();
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    analyze(command) {
+        const next = this.chain.then(() => this.request(command));
+        this.chain = next.catch(() => undefined);
+        return next;
+    }
+    dispose() {
+        this.child?.kill();
+        this.child = null;
+    }
+    start() {
+        const child = spawn(this.options.executable ?? 'powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '-'], {
+            cwd: this.options.cwd,
+            env: this.options.env,
+            windowsHide: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.onData(chunk));
+        child.stderr.resume();
+        const fail = (message) => {
+            if (this.child === child)
+                this.child = null;
+            this.waiting?.reject(new AppError('analyzer_down', 503, message));
+            this.waiting = null;
+        };
+        child.on('error', (err) => fail(`PowerShell est introuvable : ${err.message}`));
+        child.on('exit', () => fail('Le processus d’analyse s’est arrêté.'));
+        child.stdin.on('error', () => undefined);
+        child.stdin.write(`$global:PrmA = [scriptblock]::Create([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${b64(ANALYZER_SCRIPT)}')))\n`);
+        this.buffer = '';
+        return child;
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        let index = this.buffer.indexOf('\n');
+        while (index >= 0) {
+            const line = this.buffer.slice(0, index).trim();
+            this.buffer = this.buffer.slice(index + 1);
+            const w = this.waiting;
+            if (w && line.startsWith(`PRM|${w.id}|`)) {
+                this.waiting = null;
+                w.resolve(line.slice(w.id.length + 5));
+            }
+            index = this.buffer.indexOf('\n');
+        }
+    }
+    async request(command) {
+        if (!this.child)
+            this.child = this.start();
+        const child = this.child;
+        const id = randomBytes(8).toString('hex');
+        const timeoutMs = this.options.timeoutMs ?? 25_000;
+        const line = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.waiting = null;
+                child.kill();
+                if (this.child === child)
+                    this.child = null;
+                reject(new AppError('analyzer_timeout', 504, 'L’analyse de la commande a dépassé le délai.'));
+            }, timeoutMs);
+            this.waiting = {
+                id,
+                resolve: (value) => { clearTimeout(timer); resolve(value); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            };
+            child.stdin.write(`& $global:PrmA '${id}' '${b64(command)}'\n`);
+        });
+        let raw;
+        try {
+            raw = JSON.parse(Buffer.from(line, 'base64').toString('utf8'));
+        }
+        catch {
+            throw new AppError('analyzer_output', 502, 'Réponse illisible de l’analyseur PowerShell.');
+        }
+        const parsed = analysisSchema.safeParse(raw);
+        if (!parsed.success)
+            throw new AppError('analyzer_output', 502, 'Réponse inattendue de l’analyseur PowerShell.');
+        return parsed.data;
+    }
+}