@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/telephone/qr.js

@@ -0,0 +1,308 @@
+/**
+ * QR code, sans dépendance : octets, correction d'erreur M (15 %), versions 1 à 10, masque choisi par pénalité.
+ * Assez pour l'adresse d'appairage du téléphone (une soixantaine d'octets, version 4 ou 5). Suit la norme ISO/IEC 18004
+ * dans l'ordre de la construction de référence de Project Nayuki : motifs fixes, données et correction entrelacées, masque.
+ */
+const MAX_VERSION = 10;
+/** Correction M : codes de correction par bloc et nombre de blocs, par version (index 0 inutilisé). */
+const ECC_PER_BLOCK = [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26];
+const BLOCKS = [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5];
+/** Bits de format du niveau M. */
+const FORMAT_M = 0;
+/** Modules utilisables pour les données et la correction, motifs fixes retirés. */
+export function rawDataModules(version) {
+    let n = (16 * version + 128) * version + 64;
+    if (version >= 2) {
+        const align = Math.floor(version / 7) + 2;
+        n -= (25 * align - 10) * align - 55;
+        if (version >= 7)
+            n -= 36;
+    }
+    return n;
+}
+export const dataCodewords = (version) => Math.floor(rawDataModules(version) / 8) - (ECC_PER_BLOCK[version] ?? 0) * (BLOCKS[version] ?? 0);
+/** Multiplication dans GF(256), polynôme 0x11D. */
+function gfMul(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z & 0xff;
+}
+function rsDivisor(degree) {
+    const result = new Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < degree; j++) {
+            result[j] = gfMul(result[j] ?? 0, root);
+            if (j + 1 < degree)
+                result[j] = (result[j] ?? 0) ^ (result[j + 1] ?? 0);
+        }
+        root = gfMul(root, 0x02);
+    }
+    return result;
+}
+/** Codes de correction Reed-Solomon d'un bloc. */
+export function rsRemainder(data, degree) {
+    const divisor = rsDivisor(degree);
+    const result = new Array(degree).fill(0);
+    for (const b of data) {
+        const factor = b ^ (result.shift() ?? 0);
+        result.push(0);
+        divisor.forEach((coef, i) => {
+            result[i] = (result[i] ?? 0) ^ gfMul(coef, factor);
+        });
+    }
+    return result;
+}
+/** Les 15 bits de format (niveau et masque), code BCH et masque fixe compris. */
+export function formatBits(level, mask) {
+    const data = (level << 3) | mask;
+    let rem = data;
+    for (let i = 0; i < 10; i++)
+        rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+    return ((data << 10) | (rem & 0x3ff)) ^ 0x5412;
+}
+/** Les 18 bits de version (7 et plus). */
+export function versionBits(version) {
+    let rem = version;
+    for (let i = 0; i < 12; i++)
+        rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+    return (version << 12) | (rem & 0xfff);
+}
+export function alignmentPositions(version) {
+    if (version === 1)
+        return [];
+    const count = Math.floor(version / 7) + 2;
+    const size = version * 4 + 17;
+    const step = Math.floor((version * 8 + count * 3 + 5) / (count * 4 - 4)) * 2;
+    const result = [6];
+    for (let pos = size - 7; result.length < count; pos -= step)
+        result.splice(1, 0, pos);
+    return result;
+}
+/** Données en mode octet, bourrage compris, puis blocs de correction entrelacés. */
+function codewords(bytes, version) {
+    const capacity = dataCodewords(version) * 8;
+    const bits = [];
+    const put = (value, length) => {
+        for (let i = length - 1; i >= 0; i--)
+            bits.push((value >>> i) & 1);
+    };
+    put(0b0100, 4);
+    put(bytes.length, version <= 9 ? 8 : 16);
+    for (const b of bytes)
+        put(b, 8);
+    put(0, Math.min(4, capacity - bits.length));
+    put(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11)
+        put(pad, 8);
+    const data = [];
+    for (let i = 0; i < bits.length; i += 8)
+        data.push(bits.slice(i, i + 8).reduce((a, b) => (a << 1) | b, 0));
+    const blocks = BLOCKS[version] ?? 1;
+    const eccLength = ECC_PER_BLOCK[version] ?? 0;
+    const raw = Math.floor(rawDataModules(version) / 8);
+    const shortBlocks = blocks - (raw % blocks);
+    const shortLength = Math.floor(raw / blocks);
+    const all = [];
+    for (let i = 0, k = 0; i < blocks; i++) {
+        const block = data.slice(k, k + shortLength - eccLength + (i < shortBlocks ? 0 : 1));
+        k += block.length;
+        const ecc = rsRemainder(block, eccLength);
+        if (i < shortBlocks)
+            block.push(0);
+        all.push([...block, ...ecc]);
+    }
+    const result = [];
+    for (let i = 0; i < (all[0]?.length ?? 0); i++)
+        all.forEach((block, j) => {
+            if (i !== shortLength - eccLength || j >= shortBlocks)
+                result.push(block[i] ?? 0);
+        });
+    return result;
+}
+const MASKS = [
+    (x, y) => (x + y) % 2 === 0,
+    (_x, y) => y % 2 === 0,
+    (x) => x % 3 === 0,
+    (x, y) => (x + y) % 3 === 0,
+    (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+    (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+    (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+    (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+];
+class Grid {
+    size;
+    dark;
+    fixed;
+    version;
+    constructor(version) {
+        this.version = version;
+        this.size = version * 4 + 17;
+        this.dark = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.fixed = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    }
+    set(x, y, dark) {
+        const row = this.dark[y];
+        const fixed = this.fixed[y];
+        if (!row || !fixed || x < 0 || x >= this.size)
+            return;
+        row[x] = dark;
+        fixed[x] = true;
+    }
+    functionPatterns() {
+        const { size } = this;
+        for (let i = 0; i < size; i++) {
+            this.set(6, i, i % 2 === 0);
+            this.set(i, 6, i % 2 === 0);
+        }
+        for (const [cx, cy] of [
+            [3, 3],
+            [size - 4, 3],
+            [3, size - 4],
+        ])
+            for (let dy = -4; dy <= 4; dy++)
+                for (let dx = -4; dx <= 4; dx++) {
+                    const d = Math.max(Math.abs(dx), Math.abs(dy));
+                    const x = cx + dx;
+                    const y = cy + dy;
+                    if (x >= 0 && x < size && y >= 0 && y < size)
+                        this.set(x, y, d !== 2 && d !== 4);
+                }
+        const align = alignmentPositions(this.version);
+        const n = align.length;
+        for (let i = 0; i < n; i++)
+            for (let j = 0; j < n; j++) {
+                if ((i === 0 && j === 0) || (i === 0 && j === n - 1) || (i === n - 1 && j === 0))
+                    continue;
+                for (let dy = -2; dy <= 2; dy++)
+                    for (let dx = -2; dx <= 2; dx++)
+                        this.set((align[i] ?? 0) + dx, (align[j] ?? 0) + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        this.format(0);
+        if (this.version >= 7) {
+            const bits = versionBits(this.version);
+            for (let i = 0; i < 18; i++) {
+                const bit = ((bits >>> i) & 1) === 1;
+                const a = size - 11 + (i % 3);
+                const b = Math.floor(i / 3);
+                this.set(a, b, bit);
+                this.set(b, a, bit);
+            }
+        }
+    }
+    format(mask) {
+        const bits = formatBits(FORMAT_M, mask);
+        const bit = (i) => ((bits >>> i) & 1) === 1;
+        const { size } = this;
+        for (let i = 0; i <= 5; i++)
+            this.set(8, i, bit(i));
+        this.set(8, 7, bit(6));
+        this.set(8, 8, bit(7));
+        this.set(7, 8, bit(8));
+        for (let i = 9; i < 15; i++)
+            this.set(14 - i, 8, bit(i));
+        for (let i = 0; i < 8; i++)
+            this.set(size - 1 - i, 8, bit(i));
+        for (let i = 8; i < 15; i++)
+            this.set(8, size - 15 + i, bit(i));
+        this.set(8, size - 8, true);
+    }
+    place(data) {
+        const { size } = this;
+        let i = 0;
+        for (let right = size - 1; right >= 1; right -= 2) {
+            if (right === 6)
+                right = 5;
+            for (let vert = 0; vert < size; vert++)
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? size - 1 - vert : vert;
+                    const row = this.dark[y];
+                    if (row && !this.fixed[y]?.[x] && i < data.length * 8) {
+                        row[x] = (((data[i >>> 3] ?? 0) >>> (7 - (i & 7))) & 1) === 1;
+                        i++;
+                    }
+                }
+        }
+    }
+    mask(mask) {
+        const test = MASKS[mask];
+        if (!test)
+            return;
+        for (let y = 0; y < this.size; y++)
+            for (let x = 0; x < this.size; x++) {
+                const row = this.dark[y];
+                if (row && !this.fixed[y]?.[x] && test(x, y))
+                    row[x] = !row[x];
+            }
+    }
+    /** Pénalité de la norme : longues suites, carrés 2 × 2, faux motifs de repérage, déséquilibre foncé / clair. */
+    penalty() {
+        const { size, dark } = this;
+        let score = 0;
+        const line = (get) => {
+            let run = 1;
+            for (let i = 1; i <= size; i++) {
+                if (i < size && get(i) === get(i - 1))
+                    run++;
+                else {
+                    if (run >= 5)
+                        score += 3 + (run - 5);
+                    run = 1;
+                }
+            }
+            const cells = Array.from({ length: size }, (_, i) => (get(i) ? 1 : 0));
+            const text = cells.join('');
+            for (const motif of ['10111010000', '00001011101'])
+                for (let at = text.indexOf(motif); at >= 0; at = text.indexOf(motif, at + 1))
+                    score += 40;
+        };
+        for (let y = 0; y < size; y++)
+            line((x) => dark[y]?.[x] === true);
+        for (let x = 0; x < size; x++)
+            line((y) => dark[y]?.[x] === true);
+        for (let y = 0; y < size - 1; y++)
+            for (let x = 0; x < size - 1; x++) {
+                const c = dark[y]?.[x];
+                if (c === dark[y]?.[x + 1] && c === dark[y + 1]?.[x] && c === dark[y + 1]?.[x + 1])
+                    score += 3;
+            }
+        const total = dark.reduce((n, row) => n + row.filter(Boolean).length, 0);
+        const k = Math.ceil(Math.abs(total * 20 - size * size * 10) / (size * size)) - 1;
+        score += Math.max(0, k) * 10;
+        return score;
+    }
+}
+/**
+ * Le QR code d'un texte : une ligne par rangée, « 1 » pour un module foncé, sans marge. La plus petite version qui le
+ * contient. Lève une erreur au-delà de la version 10 (213 octets).
+ */
+export function qrRows(text) {
+    const bytes = new TextEncoder().encode(text);
+    let version = 1;
+    while (version <= MAX_VERSION && dataCodewords(version) * 8 < 4 + (version <= 9 ? 8 : 16) + bytes.length * 8)
+        version++;
+    if (version > MAX_VERSION)
+        throw new Error('Texte trop long pour le QR code.');
+    const data = codewords(bytes, version);
+    let best = null;
+    let bestScore = Infinity;
+    for (let m = 0; m < 8; m++) {
+        const grid = new Grid(version);
+        grid.functionPatterns();
+        grid.place(data);
+        grid.mask(m);
+        grid.format(m);
+        const score = grid.penalty();
+        if (score < bestScore) {
+            best = grid;
+            bestScore = score;
+        }
+    }
+    return (best?.dark ?? []).map((row) => row.map((d) => (d ? '1' : '0')).join(''));
+}

package/lib/shared/analysis.js

@@ -0,0 +1,40 @@
+/** Résultat de l'analyse d'une commande par le parseur de PowerShell (sans exécution). */
+import { z } from 'zod';
+const element = z.lazy(() => z.object({
+    k: z.enum(['p', 's', 'n', 'x', 'b', 'v', 'h', 'l', 'e']),
+    n: z.string().nullish().transform((v) => v ?? undefined),
+    v: z.string().nullish().transform((v) => v ?? undefined),
+    t: z.string().nullish().transform((v) => v ?? undefined),
+    bare: z.boolean().optional(),
+    splat: z.boolean().optional(),
+    a: element.optional(),
+    i: z.array(element).optional(),
+}));
+const list = (item) => z.array(item).nullish().transform((v) => v ?? []);
+const analyzedCommand = z.object({
+    name: z.string().nullable(),
+    resolved: z.string().nullable(),
+    kind: z.string(),
+    source: z.string().nullable(),
+    module: z.string().nullable(),
+    alias: z.boolean().default(false),
+    op: z.string(),
+    text: z.string(),
+    /** Éléments bruts, dans l'ordre (utile pour les applications natives). */
+    elements: list(element),
+    /** Paramètres liés par le lieur statique de PowerShell : noms complets, positions résolues. */
+    bound: list(z.object({ name: z.string(), el: element.nullable() })),
+    bindErrors: list(z.string()),
+});
+export const analysisSchema = z.object({
+    ok: z.boolean(),
+    errors: list(z.string()),
+    nodes: list(z.string()),
+    commands: list(analyzedCommand),
+    members: list(z.object({ member: z.string().nullable(), call: z.boolean(), static: z.boolean(), type: z.string().nullable() })),
+    types: list(z.string()),
+    redirections: list(z.object({ target: element, append: z.boolean(), stream: z.string() })),
+    variables: list(z.object({ name: z.string(), drive: z.string().nullable(), assigned: z.boolean().default(false), splat: z.boolean().default(false) })),
+    /** Affectations dont la cible n'est pas une simple variable : propriété ($x.P = …) ou élément ($x[0] = …). */
+    assignTargets: list(z.string()),
+});

package/lib/shared/schemas.js

@@ -0,0 +1,105 @@
+/** Validation des données reçues par le serveur (zod). Les types d'entrée en sont déduits. */
+import { z } from 'zod';
+import { fr } from 'zod/locales';
+// Messages de validation en français.
+z.config(fr());
+export const MAX_COMMAND_LENGTH = 4000;
+const command = z
+    .string()
+    .min(1, 'La commande est vide.')
+    .max(MAX_COMMAND_LENGTH, `La commande dépasse ${MAX_COMMAND_LENGTH} caractères.`)
+    .refine((s) => !s.includes('\0'), 'La commande contient un caractère nul.');
+export const previewInput = z.object({ command, cwd: z.string().min(1).max(400).optional() });
+export const runInput = z.object({
+    ticket: z.string().regex(/^[a-f0-9]{32}$/),
+    /** La confirmation humaine est obligatoire : le serveur refuse toute autre valeur. */
+    confirm: z.literal(true),
+    /** Deuxième geste exigé pour une commande sensible. */
+    acknowledge: z.boolean().optional(),
+    /** « auto » : commande de lecture tapée dans le terminal quand le réglage le permet. */
+    confirmation: z.enum(['human', 'auto']).default('human'),
+});
+export const cancelInput = z.object({ execId: z.string().regex(/^[a-f0-9]{16}$/) });
+export const cwdInput = z.object({ from: z.string().min(1).max(400), to: z.string().min(1).max(400) });
+const host = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .min(1)
+    .max(253)
+    .regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$|^[0-9a-f:]+$/, 'Nom d’hôte ou adresse IP invalide.');
+export const scopeInput = z.object({
+    host,
+    note: z.string().trim().max(200).default(''),
+    includeSubdomains: z.boolean().default(false),
+    /** Attestation obligatoire : la cible t'appartient ou tu as une autorisation écrite. */
+    attest: z.literal(true),
+});
+export const moduleId = z.enum(['surface', 'ports', 'headers', 'tls', 'web', 'exposure', 'config', 'files']);
+export const auditInput = z.object({
+    module: moduleId,
+    input: z.record(z.string(), z.string().max(2000)).default({}),
+    confirm: z.literal(true),
+});
+const customCommand = z.object({
+    name: z.string().trim().regex(/^[A-Za-z][\w.-]{0,63}$/, 'Nom de commande invalide.'),
+    level: z.enum(['read', 'sensitive']),
+});
+export const settingsPatch = z
+    .object({
+    model: z.string().max(200).nullable(),
+    engine: z
+        .object({
+        timeoutSec: z.number().int().min(5).max(300),
+        constrainedLanguage: z.boolean(),
+        confirmRead: z.boolean(),
+        roots: z.array(z.string().min(2).max(400)).min(1).max(12),
+    })
+        .partial(),
+    allowlist: z
+        .object({ custom: z.array(customCommand).max(60), unlocked: z.array(z.string().max(64)).max(60) })
+        .partial(),
+    ollama: z
+        .object({
+        baseUrl: z.string().url().max(200).refine((u) => /^https?:\/\//i.test(u), 'URL http(s) attendue.'),
+        replyTimeoutSec: z.number().int().min(10).max(900),
+    })
+        .partial(),
+    // L'adresse de SearXNG reste sur cette machine : le serveur ne s'en sert pas pour joindre un autre hôte.
+    search: z
+        .object({
+        enabled: z.boolean(),
+        url: z.string().url().max(200).refine((u) => /^http:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d{1,5})?\/?$/i.test(u), 'Adresse locale attendue, par exemple http://127.0.0.1:8888.'),
+        learn: z.boolean(),
+    })
+        .partial(),
+    fullCyber: z.boolean(),
+    autoRun: z.boolean(),
+})
+    .partial();
+/** Caractères au plus dans un message, texte tapé et pièces jointes réunis. Le petit modèle local n'en lit pas davantage. */
+export const MAX_MESSAGE_CHARS = 16000;
+const promptAttachment = z.object({
+    name: z.string().trim().min(1).max(120),
+    text: z.string().min(1).max(MAX_MESSAGE_CHARS),
+});
+export const sendInput = z
+    .object({
+    text: z.string().max(MAX_MESSAGE_CHARS).default(''),
+    /** De longs textes collés, rangés hors du champ de saisie. Leur contenu est donné au modèle à la suite du texte tapé. */
+    attachments: z.array(promptAttachment).max(6).optional(),
+})
+    .refine((d) => d.text.trim().length > 0 || (d.attachments?.length ?? 0) > 0, { error: 'Message vide.' })
+    .refine((d) => d.text.length + (d.attachments?.reduce((n, a) => n + a.text.length, 0) ?? 0) <= MAX_MESSAGE_CHARS, {
+    error: `Le message dépasse ${MAX_MESSAGE_CHARS} caractères.`,
+});
+export const decisionInput = z.object({
+    proposalId: z.string().regex(/^[a-f0-9]{16}$/),
+    decision: z.enum(['approve', 'deny']),
+    acknowledge: z.boolean().optional(),
+});
+export const newConversationInput = z.object({ model: z.string().max(200).optional() });
+/** Ouvrir ou fermer l'accès depuis le téléphone (depuis le PC seulement). */
+export const phoneToggleInput = z.object({ active: z.boolean() }).strict();
+/** Le code d'appairage tapé ou scanné sur le téléphone. */
+export const pairInput = z.object({ code: z.string().min(1).max(32) }).strict();

package/lib/shared/types.js

@@ -0,0 +1,10 @@
+/**
+ * Contrats partagés entre le serveur local et l'interface.
+ * Des types, et une seule constante (SEVERITIES).
+ */
+export const SEVERITIES = ['critical', 'high', 'medium', 'low', 'info'];
+/**
+ * Réglages qui se changent sur le PC seulement : depuis le téléphone, la politique ne peut pas être élargie. Le serveur
+ * refuse (403, pc_only) tout changement de ces champs venu du téléphone, l'interface les y montre désactivés.
+ */
+export const PC_ONLY_SETTINGS = ['engine.roots', 'engine.constrainedLanguage', 'engine.confirmRead', 'allowlist.custom', 'allowlist.unlocked', 'ollama.baseUrl', 'search.url', 'fullCyber', 'autoRun'];

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@nosserb/prmt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "Prométhée : plateforme locale de cybersécurité (console web + TUI + moteur PowerShell + Ollama).",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nosserb/prom-th-e.git"
+  },
+  "homepage": "https://github.com/nosserb/prom-th-e#readme",
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cybersecurity",
+    "cybersecurite",
+    "ollama",
+    "llm",
+    "powershell",
+    "tui",
+    "cli",
+    "pentest",
+    "ctf"
+  ],
+  "bin": {
+    "prmt": "bin/prmt.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "dist/",
+    "tui/",
+    "searxng/",
+    "docs/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "node scripts/dev.ts",
+    "build": "npm run typecheck && vite build",
+    "build:statique": "npm run typecheck && vite build --mode statique --base ./ --outDir dist-statique",
+    "start": "node server/index.ts",
+    "prmt": "node bin/prmt.mjs",
+    "lier": "node scripts/lier.ts",
+    "searxng": "node scripts/searxng.ts",
+    "pack:tui": "node scripts/pack-tui.mjs",
+    "build:server": "tsc -p tsconfig.pack.json",
+    "prepack": "npm run pack:tui && npm run build && npm run build:server",
+    "typecheck": "tsc -p tsconfig.web.json && tsc -p tsconfig.server.json && tsc -p tsconfig.e2e.json",
+    "test": "vitest run",
+    "test:e2e": "npm run build && playwright test",
+    "verify": "npm run typecheck && npm test && npm run test:e2e"
+  },
+  "dependencies": {
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@fontsource-variable/bricolage-grotesque": "^5.3.0",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0",
+    "leaflet": "^1.9.4",
+    "lucide-react": "^1.72.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "@playwright/test": "^1.65.0",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.10",
+    "@types/leaflet": "^1.9.22",
+    "@types/node": "^26.6.6",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.3.0",
+    "jsdom": "^31.0.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.8",
+    "vitest": "^5.1.0"
+  }
+}

package/searxng/settings.yml

@@ -0,0 +1,35 @@
+# SearXNG pour Prométhée : le moteur de recherche web, installé chez toi, sans clé ni compte.
+# Il interroge plusieurs moteurs (Google, Bing, DuckDuckGo, Brave, Wikipédia…) et rend leurs résultats en JSON.
+# Cartes : la catégorie « map » passe par Photon (données d'OpenStreetMap) et donne les coordonnées d'un lieu.
+# Les moteurs openstreetmap (Nominatim) et wikidata exigent une adresse de contact (general.contact_url), envoyée
+# à leurs serveurs. Elle n'est pas remplie : ils ne se chargent pas, et les cartes viennent de Photon seul.
+# Photon suspend un moment après une rafale de requêtes. Une question de lieu à la fois ne pose pas de problème.
+#
+# Copié par scripts/searxng.ts dans Documents\Promethee\searxng\, puis monté dans le conteneur.
+# Le secret n'est pas ici : scripts/searxng.ts le tire au hasard et le passe par SEARXNG_SECRET.
+# Le conteneur n'écoute que sur 127.0.0.1:8888 : rien d'autre sur le réseau ne peut s'en servir.
+
+use_default_settings: true
+
+general:
+  instance_name: "Prométhée"
+  enable_metrics: false
+
+search:
+  safe_search: 1
+  autocomplete: ""
+  default_lang: "fr-FR"
+  # json : la sortie que lit la console. html : la page de SearXNG, utile pour vérifier à la main.
+  formats:
+    - html
+    - json
+
+server:
+  # Le limiteur protège une instance publique et demande Valkey : inutile pour un seul utilisateur, en local.
+  limiter: false
+  public_instance: false
+  image_proxy: false
+  method: "GET"
+
+ui:
+  default_locale: "fr"

package/tui/Modelfile

@@ -0,0 +1,23 @@
+FROM hf.co/mradermacher/RedSage-Qwen3-8B-DPO-GGUF:Q4_K_M
+# Prométhée : basé sur RedSage-Qwen3-8B-DPO (RISys-Lab, ICLR 2026), Q4_K_M.
+# Meilleur modèle au banc d'essai (C:\Users\<utilisateur>\ollama\eval\).
+# Template ChatML hérité du GGUF (détecté automatiquement par Ollama).
+# Lancement : commande "prmt" (C:\Users\<utilisateur>\.local\bin\prmt.cmd)
+
+SYSTEM """Tu es Prométhée, une IA spécialisée en cybersécurité (offensive et défensive), en administration système et en programmation. Tu tournes en local sur la machine de l'utilisateur et tu n'as pas accès à Internet.
+L'utilisateur est un étudiant en cybersécurité.
+- Réponds toujours en français, sauf si l'utilisateur écrit dans une autre langue.
+- Sois clair et concis : adapte la longueur de la réponse à la question.
+- Sois pédagogique : explique le pourquoi, pas seulement le comment.
+- Distingue bien Windows et Linux : donne des commandes adaptées au système concerné.
+- Quand tu donnes du code ou des commandes, utilise des blocs de code et explique brièvement ce qu'ils font.
+- Si tu n'es pas sûr d'une information (numéro de CVE, version, option de commande), dis-le clairement au lieu d'inventer."""
+
+PARAMETER stop "<|im_end|>"
+PARAMETER stop "<|endoftext|>"
+PARAMETER temperature 0.5
+PARAMETER top_p 0.9
+PARAMETER repeat_penalty 1.05
+PARAMETER num_predict 2048
+# Avec OLLAMA_KV_CACHE_TYPE=q8_0 : ~72 Ko/token -> 8192 de contexte ≈ 600 Mo
+PARAMETER num_ctx 8192