@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/anonymizer/proxy.cjs

@@ -0,0 +1,365 @@
+/**
+ * Proxy PII local — le seul point de passage entre les clients IA lancés par
+ * CloudCLI (chat comme terminal) et les API des fournisseurs.
+ *
+ * Sans Python, sans venv, sans service de session à installer : il vit dans
+ * le cycle de vie du serveur CloudCLI plutôt qu'à côté.
+ *
+ * Sens sortant  : nom réel → code. Aucun nom de partie ne quitte la machine.
+ * Sens entrant  : code → nom réel. Claude Code retrouve un texte lisible, ses
+ *                 outils continuent d'ouvrir les fichiers sous leur vrai nom, et
+ *                 l'interface n'a plus qu'à surligner ce qui a été protégé.
+ *
+ * Sans mapping, le proxy est un relais transparent : le brancher ne peut pas
+ * casser une installation qui n'a encore anonymisé aucun dossier.
+ *
+ * Une route par fournisseur, distinguée par le préfixe d'URL. Un chemin qui ne
+ * correspond à aucune route est refusé : router par défaut reviendrait à
+ * laisser passer non filtré ce que l'on n'a pas su reconnaître.
+ */
+const http = require('node:http');
+const https = require('node:https');
+
+const { anonymize, deanonymize } = require('./dictionary.cjs');
+const { createSseRewriter, rewriteJsonBody } = require('./rewrite.cjs');
+const { createCollecteurTexte } = require('../harness/flux-sse.cjs');
+
+const DEFAULT_UPSTREAM = 'https://api.anthropic.com';
+
+/**
+ * Routes servies par défaut. `/chatgpt` vise le point d'entrée Codex de
+ * ChatGPT, où le CLI parle le protocole Responses avec l'authentification
+ * ChatGPT.
+ */
+const DEFAULT_ROUTES = [
+  { provider: 'claude', prefix: '/anthropic', upstream: 'https://api.anthropic.com' },
+  { provider: 'codex', prefix: '/chatgpt', upstream: 'https://chatgpt.com/backend-api/codex' },
+  { provider: 'opencode', prefix: '/openai', upstream: 'https://api.openai.com' },
+];
+
+/** Port fixe : une base écrite dans un fichier de configuration doit survivre à un redémarrage. */
+const DEFAULT_PORT = 4111;
+
+/**
+ * En-têtes que le proxy possède et ne relaie donc jamais tels quels. Le corps
+ * change de taille à la réécriture (`content-length`), et `accept-encoding` est
+ * retiré pour recevoir du texte clair : compresser en amont rendrait la
+ * dé-anonymisation impossible sans décompresser tout le flux.
+ */
+const DROPPED_REQUEST_HEADERS = new Set(['host', 'content-length', 'accept-encoding', 'connection']);
+const DROPPED_RESPONSE_HEADERS = new Set(['content-length', 'content-encoding', 'connection', 'transfer-encoding']);
+
+function pickHeaders(source, dropped) {
+  const output = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (dropped.has(key.toLowerCase())) continue;
+    output[key] = value;
+  }
+  return output;
+}
+
+function readBody(stream, limitBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    stream.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > limitBytes) {
+        reject(new Error(`Corps de requête trop volumineux (> ${limitBytes} octets).`));
+        stream.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+  });
+}
+
+function isJsonLike(contentType) {
+  return /\bjson\b/i.test(String(contentType || ''));
+}
+
+function isEventStream(contentType) {
+  return /text\/event-stream/i.test(String(contentType || ''));
+}
+
+/**
+ * Texte assistant d'un corps JSON complet (non streamé), pour le harnais de
+ * citations : formes Anthropic Messages (`content[]`, blocs `{type:'text'}`)
+ * et Responses d'OpenAI (`output[].content[]`, blocs `{type:'output_text'}`).
+ * Ne jette jamais : un corps illisible ou d'une autre forme renvoie `''`.
+ */
+function extractAssistantTextFromJson(raw) {
+  try {
+    const parsed = JSON.parse(typeof raw === 'string' ? raw : raw.toString('utf8'));
+    if (!parsed || typeof parsed !== 'object') return '';
+    if (Array.isArray(parsed.content)) {
+      return parsed.content
+        .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('');
+    }
+    if (Array.isArray(parsed.output)) {
+      return parsed.output
+        .flatMap((item) => (Array.isArray(item?.content) ? item.content : []))
+        .filter((block) => block?.type === 'output_text' && typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('');
+    }
+    return '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * @param {object} options
+ * @param {{ get: () => object }} options.dictionary Chargeur de mapping à chaud.
+ * @param {Array<{provider: string, prefix: string, upstream: string}>} [options.routes]
+ *   Table de routage ; le préfixe le plus long l'emporte.
+ * @param {number} [options.port] Port préféré ; 0 = port éphémère.
+ * @param {object|null} [options.harness] Harnais de citations vérifiées
+ *   (`../harness/index.cjs`), absent par défaut : sans lui, le proxy se
+ *   comporte exactement comme s'il n'existait pas.
+ */
+function createAnonymizerProxy({
+  dictionary,
+  routes = DEFAULT_ROUTES,
+  port = DEFAULT_PORT,
+  host = '127.0.0.1',
+  maxBodyBytes = 64 * 1024 * 1024,
+  onError = () => {},
+  harness = null,
+} = {}) {
+  // Préfixe le plus long d'abord : `/anthropic/v1` doit gagner sur `/anthropic`
+  // si les deux sont déclarés un jour.
+  const table = [...routes]
+    .map((route) => ({ ...route, target: new URL(route.upstream) }))
+    .sort((left, right) => right.prefix.length - left.prefix.length);
+  const stats = { requests: 0, anonymized: 0, deanonymized: 0, failures: 0, lastError: null };
+
+  // Observation du harnais de citations, en espace clair des deux côtés
+  // (corps brut du client à l'aller, texte livré au client au retour) — voir
+  // `../harness/index.cjs`. Ne doit jamais retarder ni faire échouer une
+  // requête ou une réponse déjà en cours, même si le harnais fourni est
+  // défaillant (double garde : `index.cjs` ne jette déjà jamais, mais le
+  // proxy ne doit dépendre de cette garantie).
+  function observerRequete(rawBody, contentType, session) {
+    if (!harness) return;
+    try {
+      harness.observerRequete(rawBody, contentType, { session });
+    } catch {
+      // jamais bloquant pour la requête en cours
+    }
+  }
+
+  function observerReponse(texteAssistant, session) {
+    if (!harness) return;
+    try {
+      Promise.resolve(harness.observerReponse(texteAssistant, { session })).catch(() => {});
+    } catch {
+      // jamais bloquant pour une réponse déjà envoyée au client
+    }
+  }
+
+  function matchRoute(url) {
+    return table.find((route) => url === route.prefix || url.startsWith(`${route.prefix}/`) || url.startsWith(`${route.prefix}?`));
+  }
+
+  const server = http.createServer((clientRequest, clientResponse) => {
+    stats.requests += 1;
+    const current = dictionary.get();
+
+    const route = matchRoute(clientRequest.url || '');
+    if (!route) {
+      stats.failures += 1;
+      stats.lastError = `Chemin non routé : ${clientRequest.url}`;
+      clientResponse.writeHead(404, { 'content-type': 'application/json' });
+      clientResponse.end(JSON.stringify({
+        error: {
+          type: 'piecemaker_proxy',
+          message: `Aucune route d'anonymisation pour ${clientRequest.url}. Requête refusée plutôt que relayée sans filtrage.`,
+        },
+      }));
+      return;
+    }
+    const { target } = route;
+    const transport = target.protocol === 'http:' ? http : https;
+    const forwardedPath = `${target.pathname.replace(/\/$/, '')}${clientRequest.url.slice(route.prefix.length) || '/'}`;
+
+    void (async () => {
+      let body = Buffer.alloc(0);
+      try {
+        body = await readBody(clientRequest, maxBodyBytes);
+      } catch (error) {
+        stats.failures += 1;
+        stats.lastError = error.message;
+        clientResponse.writeHead(413, { 'content-type': 'application/json' });
+        clientResponse.end(JSON.stringify({ error: { type: 'piecemaker_proxy', message: error.message } }));
+        return;
+      }
+
+      // Corps brut, AVANT anonymisation : le harnais doit voir le même texte
+      // que le client a envoyé, pas les codes qui partent vers le fournisseur.
+      observerRequete(body, clientRequest.headers['content-type'], route.provider);
+
+      let outgoing = body;
+      if (body.length && !current.empty && isJsonLike(clientRequest.headers['content-type'])) {
+        const rewritten = rewriteJsonBody(body, (text) => anonymize(text, current));
+        outgoing = Buffer.from(rewritten, 'utf8');
+        if (!outgoing.equals(body)) stats.anonymized += 1;
+      }
+
+      const headers = pickHeaders(clientRequest.headers, DROPPED_REQUEST_HEADERS);
+      headers.host = target.host;
+      headers['accept-encoding'] = 'identity';
+      if (outgoing.length) headers['content-length'] = String(outgoing.length);
+
+      const upstreamRequest = transport.request(
+        {
+          protocol: target.protocol,
+          hostname: target.hostname,
+          port: target.port || (target.protocol === 'http:' ? 80 : 443),
+          method: clientRequest.method,
+          path: forwardedPath,
+          headers,
+        },
+        (upstreamResponse) => {
+          const responseHeaders = pickHeaders(upstreamResponse.headers, DROPPED_RESPONSE_HEADERS);
+          clientResponse.writeHead(upstreamResponse.statusCode || 502, responseHeaders);
+
+          if (current.empty) {
+            // Rien à dé-anonymiser, mais le harnais observe quand même ce qui
+            // est livré au client — inchangé, aucune réécriture ici.
+            if (isEventStream(upstreamResponse.headers['content-type'])) {
+              const collecteur = createCollecteurTexte();
+              upstreamResponse.setEncoding('utf8');
+              upstreamResponse.on('data', (chunk) => {
+                collecteur.push(chunk);
+                clientResponse.write(chunk);
+              });
+              upstreamResponse.on('end', () => {
+                clientResponse.end();
+                observerReponse(collecteur.texte(), route.provider);
+              });
+              upstreamResponse.on('error', () => clientResponse.end());
+              return;
+            }
+            if (isJsonLike(upstreamResponse.headers['content-type'])) {
+              const chunks = [];
+              upstreamResponse.on('data', (chunk) => chunks.push(chunk));
+              upstreamResponse.on('end', () => {
+                const raw = Buffer.concat(chunks);
+                clientResponse.end(raw);
+                observerReponse(extractAssistantTextFromJson(raw), route.provider);
+              });
+              upstreamResponse.on('error', () => clientResponse.end());
+              return;
+            }
+            upstreamResponse.pipe(clientResponse);
+            return;
+          }
+
+          const revert = (text) => deanonymize(text, current);
+
+          if (isEventStream(upstreamResponse.headers['content-type'])) {
+            const rewriter = createSseRewriter(revert);
+            const collecteur = createCollecteurTexte();
+            upstreamResponse.setEncoding('utf8');
+            upstreamResponse.on('data', (chunk) => {
+              const out = rewriter.push(chunk);
+              if (out) {
+                clientResponse.write(out);
+                collecteur.push(out);
+              }
+            });
+            upstreamResponse.on('end', () => {
+              const tail = rewriter.end();
+              if (tail) {
+                clientResponse.write(tail);
+                collecteur.push(tail);
+              }
+              stats.deanonymized += 1;
+              clientResponse.end();
+              observerReponse(collecteur.texte(), route.provider);
+            });
+            upstreamResponse.on('error', () => clientResponse.end());
+            return;
+          }
+
+          if (isJsonLike(upstreamResponse.headers['content-type'])) {
+            const chunks = [];
+            upstreamResponse.on('data', (chunk) => chunks.push(chunk));
+            upstreamResponse.on('end', () => {
+              const raw = Buffer.concat(chunks);
+              const rewritten = rewriteJsonBody(raw, revert);
+              stats.deanonymized += 1;
+              clientResponse.end(rewritten);
+              observerReponse(extractAssistantTextFromJson(rewritten), route.provider);
+            });
+            upstreamResponse.on('error', () => clientResponse.end());
+            return;
+          }
+
+          upstreamResponse.pipe(clientResponse);
+        },
+      );
+
+      upstreamRequest.on('error', (error) => {
+        stats.failures += 1;
+        stats.lastError = error.message;
+        onError(error);
+        if (clientResponse.headersSent) {
+          clientResponse.end();
+          return;
+        }
+        clientResponse.writeHead(502, { 'content-type': 'application/json' });
+        clientResponse.end(JSON.stringify({
+          error: { type: 'piecemaker_proxy', message: `Relais indisponible : ${error.message}` },
+        }));
+      });
+
+      if (outgoing.length) upstreamRequest.write(outgoing);
+      upstreamRequest.end();
+    })();
+  });
+
+  function listenOn(candidate) {
+    return new Promise((resolve, reject) => {
+      const onError = (error) => reject(error);
+      server.once('error', onError);
+      server.listen(candidate, host, () => {
+        server.removeListener('error', onError);
+        const address = server.address();
+        resolve({ port: address.port, origin: `http://${host}:${address.port}` });
+      });
+    });
+  }
+
+  return {
+    stats,
+    get listening() { return server.listening; },
+    routes: table.map(({ provider, prefix, target }) => ({ provider, prefix, upstream: target.origin })),
+    /**
+     * Écoute le port demandé, et lui seul. La base écrite dans les
+     * configurations des clients leur survit sur disque : un port qui dérive
+     * la rend définitivement fausse pour la session suivante. Un port déjà
+     * pris signale une instance encore vivante, pas une invitation à bouger.
+     */
+    async listen() {
+      try {
+        return await listenOn(port);
+      } catch (error) {
+        if (error.code !== 'EADDRINUSE') throw error;
+        throw new Error(`Port ${port} déjà occupé : une instance du proxy PII écoute encore. `
+          + `Arrêtez-la (lsof -nP -iTCP:${port} -sTCP:LISTEN) avant de redémarrer.`);
+      }
+    },
+    close() {
+      return new Promise((resolve) => server.close(() => resolve()));
+    },
+  };
+}
+
+module.exports = { DEFAULT_UPSTREAM, createAnonymizerProxy };

package/server/piecemaker/anonymizer/rewrite.cjs

@@ -0,0 +1,251 @@
+/**
+ * Réécriture des charges utiles qui traversent le proxy PII.
+ *
+ * Deux formes, deux difficultés très inégales :
+ *
+ *  - **JSON complet** (requêtes, réponses non streamées). Le corps est entier,
+ *    on le parcourt et on substitue. Sans surprise.
+ *
+ *  - **SSE streamé** (`text/event-stream`, le cas normal d'une conversation).
+ *    Le modèle émet un code en plusieurs fragments : « PERSONNE_ », « PHYSIQUE »,
+ *    « _01 » arrivent dans trois événements `content_block_delta` distincts.
+ *    Substituer fragment par fragment ne trouverait jamais rien. La solution est
+ *    de retenir la fin de mot en cours tant qu'elle peut encore s'allonger, et
+ *    de ne livrer que ce qui est définitivement terminé. Les consommateurs
+ *    concatènent les deltas : découper autrement qu'à la source est sans effet,
+ *    seule la concaténation finale compte.
+ *
+ * Le tampon de retenue est borné : au-delà, le fragment ne peut plus être un
+ * code et il est livré tel quel plutôt que de retenir indéfiniment.
+ */
+
+/** Au-delà, une suite de caractères de mot n'est plus un code plausible. */
+const MAX_HELD_WORD = 128;
+
+/** Caractères qu'un code peut contenir — lettres, chiffres et underscore. */
+const TRAILING_WORD = /[\p{L}\p{N}_]+$/u;
+
+/**
+ * Longueur de la fin de mot à retenir : livrer « PERSONNE_PHYSIQUE_01 » alors
+ * que le fragment suivant apporte « _SA » produirait une dé-anonymisation
+ * fausse au milieu d'un identifiant plus long.
+ */
+function heldLength(buffer) {
+  const match = TRAILING_WORD.exec(buffer);
+  if (!match) return 0;
+  return match[0].length > MAX_HELD_WORD ? 0 : match[0].length;
+}
+
+/**
+ * Réécrit récursivement toutes les chaînes d'une valeur JSON, clés comprises :
+ * un nom réel peut aussi bien être une valeur de `tool_result` qu'une clé
+ * produite par un listing de fichiers.
+ */
+function rewriteJsonValue(value, transform) {
+  if (typeof value === 'string') return transform(value);
+  if (Array.isArray(value)) return value.map((item) => rewriteJsonValue(item, transform));
+  if (value && typeof value === 'object') {
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+      output[transform(key)] = rewriteJsonValue(item, transform);
+    }
+    return output;
+  }
+  return value;
+}
+
+/**
+ * Réécrit un corps JSON sérialisé. Si le corps n'est pas du JSON analysable, on
+ * substitue sur le texte brut : moins précis, mais une charge utile non
+ * analysée ne doit jamais sortir en clair.
+ */
+function rewriteJsonBody(raw, transform) {
+  if (!raw) return raw;
+  const text = typeof raw === 'string' ? raw : raw.toString('utf8');
+  try {
+    return JSON.stringify(rewriteJsonValue(JSON.parse(text), transform));
+  } catch {
+    return transform(text);
+  }
+}
+
+/** Les champs d'un événement SSE qui portent du texte produit par le modèle. */
+/** Champs texte d'un `content_block_delta` Anthropic. */
+const DELTA_TEXT_FIELDS = ['text', 'thinking', 'partial_json'];
+
+/**
+ * Transformateur d'un flux SSE.
+ *
+ * Trois formats de fil traversent ce proxy et tous découpent le texte en
+ * fragments : Anthropic (`content_block_delta`), Responses d'OpenAI —
+ * qu'utilise Codex — (`response.output_text.delta`) et Chat Completions —
+ * qu'utilisent la plupart des fournisseurs compatibles OpenAI, dont opencode
+ * (`choices[].delta.content`). Un seul mécanisme les couvre : une retenue de
+ * fin de mot par bloc de texte concurrent, et une façon de resynthétiser un
+ * delta au format d'origine pour vider cette retenue avant la fin du bloc.
+ *
+ * Chaque retenue mémorise donc son propre `synth` : le vidage sait reproduire
+ * l'événement dans le format où il est arrivé, sans que le reste du code ait à
+ * connaître les trois formes.
+ */
+function createSseRewriter(transform) {
+  let pendingLines = '';
+  const held = new Map();
+
+  /** Retient la fin de mot en cours et rend ce qui est définitivement livrable. */
+  function rewriteDelta(key, fragment, synth, synthType) {
+    const entry = held.get(key);
+    const buffer = (entry ? entry.tail : '') + fragment;
+    const keep = heldLength(buffer);
+    const emitted = keep ? buffer.slice(0, buffer.length - keep) : buffer;
+    held.set(key, { tail: keep ? buffer.slice(buffer.length - keep) : '', synth, synthType });
+    return emitted ? transform(emitted) : '';
+  }
+
+  /** Rend le delta de rattrapage d'un bloc terminé, ou null s'il n'y a rien à vider. */
+  function flushKey(key) {
+    const entry = held.get(key);
+    held.delete(key);
+    if (!entry || !entry.tail) return null;
+    return { json: entry.synth(transform(entry.tail)), type: entry.synthType };
+  }
+
+  /** Rend les lignes d'un événement SSE. */
+  function lines(json, eventName) {
+    return eventName ? `event: ${eventName}\ndata: ${json}` : `data: ${json}`;
+  }
+
+  /**
+   * Fait précéder un événement des deltas de rattrapage des blocs qu'il termine.
+   *
+   * Le nom d'événement est réémis avec chaque charge utile : le `event:` déjà
+   * présent en amont dans le flux serait sinon attribué au premier delta injecté
+   * — un client Anthropic verrait un delta étiqueté `content_block_stop`. Un
+   * champ SSE répété étant écrasé par le dernier, réémettre est sans risque.
+   */
+  function withFlush(keys, eventJson, eventName) {
+    const parts = [];
+    for (const key of keys) {
+      const extra = flushKey(key);
+      if (extra) parts.push(lines(extra.json, extra.type));
+    }
+    if (!parts.length) return lines(eventJson, undefined);
+    parts.push(lines(eventJson, eventName));
+    return parts.join('\n\n');
+  }
+
+  function rewriteAnthropic(parsed) {
+    const index = Number.isInteger(parsed.index) ? parsed.index : 0;
+    const key = `a:${index}`;
+    const synth = (text) => JSON.stringify({ type: 'content_block_delta', index, delta: { type: 'text_delta', text } });
+
+    if (parsed.type === 'content_block_delta' && parsed.delta) {
+      for (const field of DELTA_TEXT_FIELDS) {
+        if (typeof parsed.delta[field] !== 'string') continue;
+        parsed.delta[field] = rewriteDelta(key, parsed.delta[field], synth, 'content_block_delta');
+      }
+      return lines(JSON.stringify(parsed), undefined);
+    }
+    // Le reste retenu doit sortir AVANT la fin du bloc : on le raccroche à un
+    // dernier delta, faute de quoi la fin du dernier mot serait perdue.
+    return withFlush([key], JSON.stringify(parsed), parsed.type);
+  }
+
+  /**
+   * API Responses : le texte arrive dans `delta` (une chaîne nue), identifié par
+   * `item_id` — le même item peut porter plusieurs parts, d'où `content_index`.
+   */
+  function rewriteResponses(parsed) {
+    const owner = parsed.item_id ?? parsed.output_index ?? 0;
+    const part = parsed.content_index ?? 0;
+    const key = `r:${owner}:${part}`;
+    const synth = (delta) => JSON.stringify({ ...parsed, type: 'response.output_text.delta', delta });
+
+    if (typeof parsed.delta === 'string') {
+      parsed.delta = rewriteDelta(key, parsed.delta, synth, 'response.output_text.delta');
+      return lines(JSON.stringify(parsed), undefined);
+    }
+    // `response.completed` clôt tout le flux, les autres `.done` un seul bloc.
+    const keys = parsed.type === 'response.completed' ? [...held.keys()] : [key];
+    return withFlush(keys, JSON.stringify(parsed), parsed.type);
+  }
+
+  /** Chat Completions : un delta par `choices[i]`, terminé par `finish_reason`. */
+  function rewriteChatChunk(parsed) {
+    const flushed = [];
+    for (const choice of parsed.choices) {
+      if (!choice || typeof choice !== 'object') continue;
+      const index = Number.isInteger(choice.index) ? choice.index : 0;
+      const key = `c:${index}`;
+      const synth = (content) => JSON.stringify({
+        ...parsed,
+        choices: [{ index, delta: { content }, finish_reason: null }],
+      });
+      for (const field of ['content', 'reasoning_content', 'refusal']) {
+        if (typeof choice.delta?.[field] !== 'string') continue;
+        choice.delta[field] = rewriteDelta(key, choice.delta[field], synth, undefined);
+      }
+      if (choice.finish_reason) flushed.push(key);
+    }
+    return withFlush(flushed, JSON.stringify(parsed), undefined);
+  }
+
+  function rewriteEventPayload(payload) {
+    // Sentinelle de fin des flux OpenAI : dernière occasion de vider les retenues.
+    if (payload.trim() === '[DONE]') return withFlush([...held.keys()], payload, undefined);
+
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      return transform(payload);
+    }
+    if (!parsed || typeof parsed !== 'object') return lines(JSON.stringify(rewriteJsonValue(parsed, transform)), undefined);
+
+    if (typeof parsed.type === 'string' && parsed.type.startsWith('content_block')) return rewriteAnthropic(parsed);
+    if (typeof parsed.type === 'string' && parsed.type.startsWith('response.')) return rewriteResponses(parsed);
+    if (Array.isArray(parsed.choices)) return rewriteChatChunk(parsed);
+
+    // Les événements restants (message_start, message_delta, error, en-têtes de
+    // flux) ne portent pas de texte fragmenté, mais peuvent porter des libellés.
+    return lines(JSON.stringify(rewriteJsonValue(parsed, transform)), undefined);
+  }
+
+  return {
+    /** Consomme un morceau du flux, rend ce qui peut être livré maintenant. */
+    push(chunk) {
+      pendingLines += chunk;
+      // Un événement SSE se termine par une ligne vide ; on ne traite que ce qui
+      // est complet et on garde le reste pour le morceau suivant.
+      const boundary = pendingLines.lastIndexOf('\n\n');
+      if (boundary === -1) return '';
+      const complete = pendingLines.slice(0, boundary + 2);
+      pendingLines = pendingLines.slice(boundary + 2);
+
+      return complete
+        .split('\n')
+        .map((line) => (line.startsWith('data: ') ? rewriteEventPayload(line.slice(6)) : line))
+        .join('\n');
+    },
+
+    /** Fin de flux : livre les lignes incomplètes et toutes les retenues. */
+    end() {
+      let output = pendingLines;
+      pendingLines = '';
+      for (const key of [...held.keys()]) {
+        const extra = flushKey(key);
+        if (!extra) continue;
+        output += `${lines(extra.json, extra.type)}\n\n`;
+      }
+      return output;
+    },
+  };
+}
+
+module.exports = {
+  MAX_HELD_WORD,
+  createSseRewriter,
+  heldLength,
+  rewriteJsonBody,
+  rewriteJsonValue,
+};

package/server/piecemaker/anonymizer/routes.cjs

@@ -0,0 +1,43 @@
+/**
+ * Routes de l'anonymisation, montées sous `/api/piecemaker` derrière
+ * `authenticateToken`.
+ *
+ * `/dictionary` ne renvoie que les orthographes dont l'interface a besoin pour
+ * surligner : jamais le sens nom → code, jamais les codes eux-mêmes, jamais le
+ * fichier de mapping. Les noms qui en sortent sont ceux que le chat affiche
+ * déjà, la route n'expose donc rien de plus que l'écran. Les variantes en font
+ * partie : une même personne s'y écrit de plusieurs façons, et une orthographe
+ * absente de cette liste resterait sans teinte à l'écran.
+ *
+ * `names` et `acronyms` sont séparés parce que le moteur de substitution les
+ * traite différemment — casse ignorée pour les premiers, casse respectée pour
+ * les seconds. L'interface reproduit cette règle telle quelle : le surlignage
+ * doit désigner exactement ce que le proxy code.
+ */
+function createAnonymizerRouter({ service }) {
+  const express = require('express');
+  const router = express.Router();
+
+  router.get('/anonymizer/status', (_req, res) => {
+    res.json(service.status());
+  });
+
+  router.get('/anonymizer/dictionary', (_req, res) => {
+    const dictionary = service.dictionary.get();
+    res.json({
+      version: dictionary.version,
+      updatedAt: dictionary.updatedAt,
+      names: dictionary.displayNames,
+      acronyms: dictionary.displayAcronyms,
+    });
+  });
+
+  router.post('/anonymizer/refresh', (_req, res) => {
+    service.dictionary.refresh();
+    res.json(service.status());
+  });
+
+  return router;
+}
+
+module.exports = { createAnonymizerRouter };