@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/anonymizer/dictionary.cjs

@@ -0,0 +1,174 @@
+/**
+ * Dictionnaire d'anonymisation du proxy PII.
+ *
+ * Source unique : le mapping central écrit par `central-mapping.cjs` lors de
+ * l'enregistrement d'un mapping de dossier. Il réunit tous les dossiers
+ * enregistrés avec des codes dé-conflictés, ce qui est exactement ce qu'un
+ * chokepoint réseau demande : un nom appartenant au dossier B doit rester
+ * protégé même s'il est tapé dans une conversation ouverte sur le dossier A.
+ * Un proxy par dossier ne saurait pas le faire.
+ *
+ * Le fichier contient des noms réels (mode 0600). Il n'est jamais servi tel
+ * quel : `routes.cjs` n'en expose que ce dont l'interface a besoin pour
+ * surligner, et seulement derrière l'authentification CloudCLI.
+ *
+ * Rechargement à chaud sur `mtime` : une conversion qui ré-écrit le mapping est
+ * prise en compte sans redémarrer CloudCLI.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  applyMapping,
+  buildEntityRegex,
+  revertMapping,
+  MIN_ENTITY_LENGTH,
+} = require('../vendor/piecemaker-plugin/scripts/lib/substitution.cjs');
+
+const CENTRAL_FILENAME = 'central-mapping.json';
+
+/** Un dictionnaire vide se comporte comme un proxy transparent. */
+const EMPTY = Object.freeze({
+  version: 0,
+  updatedAt: null,
+  mapping: Object.freeze({}),
+  reverse: Object.freeze({}),
+  canonical: Object.freeze({}),
+  displayNames: Object.freeze([]),
+  displayAcronyms: Object.freeze([]),
+  entityCount: 0,
+  codeCount: 0,
+  empty: true,
+});
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, ''));
+  } catch {
+    return null;
+  }
+}
+
+function plainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+/**
+ * Construit le dictionnaire exploitable à partir du document central.
+ *
+ * `canonical` est la projection code → orthographe principale, celle que
+ * `revertMapping` rend à l'humain.
+ *
+ * `displayNames` et `displayAcronyms` sont ce que l'interface surligne. Ils
+ * sortent des clés de `mapping`, c'est-à-dire des orthographes que
+ * `applyMapping` code réellement — variantes secondaires comprises — et non de
+ * `reverse_mapping`, qui ne porte que la forme principale. Une entité que le
+ * moteur refuse de substituer (`buildEntityRegex` nul : ponctuation pure, deux
+ * caractères non acronymiques) est écartée des deux listes : surligner ce qui
+ * ne part pas codé serait un mensonge à l'écran.
+ *
+ * La séparation des deux listes reproduit la seule asymétrie du moteur : au-delà
+ * de `MIN_ENTITY_LENGTH`, la casse est ignorée ; à deux caractères, l'acronyme
+ * reste sensible à la casse, faute de quoi « US » emporterait le pronom « us ».
+ */
+function buildDictionary(document, stamp) {
+  const mapping = plainObject(document?.mapping);
+  const reverse = plainObject(document?.reverse_mapping);
+  const canonical = {};
+  for (const [code, variants] of Object.entries(reverse)) {
+    const name = Array.isArray(variants) ? variants[0] : variants;
+    if (typeof name === 'string' && name.trim()) canonical[code] = name;
+  }
+
+  const foldedNames = new Map();
+  const acronyms = new Set();
+  for (const entity of Object.keys(mapping)) {
+    if (!buildEntityRegex(entity)) continue;
+    const trimmed = entity.trim();
+    if (trimmed.length < MIN_ENTITY_LENGTH) {
+      acronyms.add(trimmed);
+      continue;
+    }
+    const folded = trimmed.toLocaleLowerCase();
+    if (!foldedNames.has(folded)) foldedNames.set(folded, trimmed);
+  }
+  const displayNames = Array.from(foldedNames.values());
+  const displayAcronyms = Array.from(acronyms);
+  const entityCount = Object.keys(mapping).length;
+  const codeCount = Object.keys(canonical).length;
+  return {
+    version: stamp,
+    updatedAt: typeof document?.updated_at === 'string' ? document.updated_at : null,
+    mapping,
+    reverse,
+    canonical,
+    displayNames,
+    displayAcronyms,
+    entityCount,
+    codeCount,
+    empty: entityCount === 0 && codeCount === 0,
+  };
+}
+
+/**
+ * Chargeur à cache : relit le fichier uniquement quand sa signature
+ * (mtime + taille) change. `version` s'incrémente à chaque rechargement effectif,
+ * ce qui sert de clé de cache aux consommateurs (client compris).
+ */
+function createDictionaryLoader({ homeDir }) {
+  const file = path.join(homeDir, CENTRAL_FILENAME);
+  let signature = null;
+  let current = EMPTY;
+  let generation = 0;
+
+  function statSignature() {
+    try {
+      const stats = fs.statSync(file);
+      return `${stats.mtimeMs}:${stats.size}`;
+    } catch {
+      return null;
+    }
+  }
+
+  function load(force = false) {
+    const next = statSignature();
+    if (!force && next === signature) return current;
+    signature = next;
+    if (next === null) {
+      current = EMPTY;
+      return current;
+    }
+    const document = readJson(file);
+    generation += 1;
+    current = document ? buildDictionary(document, generation) : EMPTY;
+    return current;
+  }
+
+  return {
+    file,
+    /** Le dictionnaire à jour, relu si le fichier a bougé. */
+    get: () => load(false),
+    /** Relecture inconditionnelle, pour le bouton « rafraîchir ». */
+    refresh: () => load(true),
+    exists: () => statSignature() !== null,
+  };
+}
+
+/** Nom réel → code, sur tout ce qui part vers l'API. */
+function anonymize(text, dictionary) {
+  return dictionary.empty ? text : applyMapping(text, dictionary.mapping);
+}
+
+/** Code → nom réel, sur tout ce qui revient de l'API vers la machine. */
+function deanonymize(text, dictionary) {
+  return dictionary.empty ? text : revertMapping(text, dictionary.reverse);
+}
+
+module.exports = {
+  CENTRAL_FILENAME,
+  EMPTY_DICTIONARY: EMPTY,
+  anonymize,
+  buildDictionary,
+  createDictionaryLoader,
+  deanonymize,
+};

package/server/piecemaker/anonymizer/lifecycle.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { startRequiredAnonymizer } from './lifecycle.js';
+
+test('le démarrage attend écoute et configuration avant de rendre la main', async () => {
+  let release!: () => void;
+  const pending = new Promise<void>((resolve) => { release = resolve; });
+  let ready = false;
+  const service = {
+    start: () => pending.then(() => { ready = true; }),
+    stop: async () => {},
+    status: () => ({ enabled: ready, listening: ready, coverage: { claude: { state: 'filtered' }, codex: { state: 'filtered' } } }),
+  };
+  let returned = false;
+  const startup = startRequiredAnonymizer(service).then((guard) => { returned = true; return guard; });
+  await Promise.resolve();
+  assert.equal(returned, false);
+  release();
+  const guard = await startup;
+  assert.equal(returned, true);
+  guard();
+  ready = false;
+  assert.throws(guard, /proxy PII est indisponible/);
+});
+
+test('échec du proxy ou configuration Codex manquante : démarrage refusé et ressources fermées', async () => {
+  for (const listening of [true, false]) {
+    let stopped = false;
+    await assert.rejects(startRequiredAnonymizer({
+      start: async () => {},
+      stop: async () => { stopped = true; },
+      status: () => ({ enabled: listening, listening, coverage: { claude: { state: 'filtered' }, codex: { state: 'unconfigured' } } }),
+    }), /Démarrage IA refusé/);
+    assert.equal(stopped, true);
+  }
+});

package/server/piecemaker/anonymizer/lifecycle.ts

@@ -0,0 +1,22 @@
+type AnonymizerService = {
+  start(): Promise<unknown>;
+  stop(): Promise<unknown>;
+  status(): { enabled: boolean; listening: boolean; coverage: Record<string, { state: string }> };
+};
+
+export async function startRequiredAnonymizer(service: AnonymizerService) {
+  const ensureReady = () => {
+    const status = service.status();
+    if (!status.enabled || !status.listening) throw new Error('PieceMaker : le proxy PII est indisponible. Démarrage IA refusé.');
+    const missing = ['claude', 'codex'].filter((provider) => status.coverage[provider]?.state !== 'filtered');
+    if (missing.length) throw new Error(`PieceMaker : routage PII non configuré pour ${missing.join(', ')}. Démarrage IA refusé.`);
+  };
+  try {
+    await service.start();
+    ensureReady();
+  } catch (error) {
+    await service.stop();
+    throw error;
+  }
+  return ensureReady;
+}

package/server/piecemaker/anonymizer/providers.cjs

@@ -0,0 +1,241 @@
+/**
+ * Branchement des quatre clients IA de CloudCLI sur le proxy PII.
+ *
+ * Chaque client a son propre levier, et un seul est universel : la variable
+ * d'environnement du serveur, dont héritent les quatre chemins de lancement.
+ * Elle ne suffit pourtant que là où le CLI honore une base d'URL, d'où un
+ * second levier — le fichier de configuration utilisateur — pour Codex et
+ * opencode, et un troisième pour Cursor, qui n'en honore aucun.
+ *
+ *  | client   | levier                                             |
+ *  |----------|----------------------------------------------------|
+ *  | claude   | `ANTHROPIC_BASE_URL` + `~/.claude/settings.json`   |
+ *  | codex    | `~/.codex/config.toml` (bloc géré)                  |
+ *  | opencode | `provider.*.options.baseURL` de sa configuration    |
+ *  | cursor   | aucun — voir plus bas                               |
+ *
+ * **Cursor.** `cursor-agent` parle le protocole d'authentification de Cursor et
+ * ignore toute base d'URL : il n'est pas interceptable. Le laisser tourner
+ * enverrait des noms de parties en clair. À défaut de pouvoir le filtrer, on
+ * l'empêche de partir : un exécutable `cursor-agent` posé en tête de `PATH`
+ * refuse de s'exécuter tant qu'un mapping existe, et relaie le vrai binaire
+ * sinon. C'est le seul fournisseur pour lequel la garantie se paie d'un refus,
+ * et cela reste préférable à une fuite silencieuse.
+ *
+ * La configuration Claude et Codex est écrite par `./client-config.cjs`,
+ * propre à ce dépôt : écriture atomique, détection de conflit et
+ * réversibilité, sous l'identifiant de bloc `piecemaker_proxy`.
+ */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  configureClaudeCodeProxy,
+  bypassClaudeCodeProxy,
+  configureCodexProxy,
+  bypassCodexProxy,
+} = require('./client-config.cjs');
+
+/** Une base que PieceMaker a écrite — donc que PieceMaker peut réécrire ou retirer. */
+function isOwnLoopbackUrl(value, suffix) {
+  try {
+    const url = new URL(String(value || ''));
+    return ['127.0.0.1', 'localhost'].includes(url.hostname)
+      && url.pathname.replace(/\/$/, '') === suffix;
+  } catch {
+    return false;
+  }
+}
+
+function opencodeConfigFile(userHome) {
+  if (process.env.OPENCODE_CONFIG) return process.env.OPENCODE_CONFIG;
+  const base = process.env.XDG_CONFIG_HOME || path.join(userHome, '.config');
+  return path.join(base, 'opencode', 'opencode.json');
+}
+
+function writeJsonAtomic(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.piecemaker-${process.pid}`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temporary, file);
+}
+
+/**
+ * opencode lit `provider.<id>.options.baseURL`. On câble les deux familles que
+ * le proxy sait router ; les autres fournisseurs éventuellement configurés
+ * restent intacts, et donc hors couverture — le statut le dit.
+ */
+const OPENCODE_ROUTES = [
+  { id: 'anthropic', suffix: '/anthropic' },
+  { id: 'openai', suffix: '/openai' },
+];
+
+function configureOpencode({ origin, userHome }) {
+  const file = opencodeConfigFile(userHome);
+  let config = {};
+  try {
+    if (fs.existsSync(file)) {
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('objet JSON attendu');
+      config = parsed;
+    }
+  } catch {
+    return { configured: false, changed: false, conflict: true, file, reason: 'config-invalid' };
+  }
+
+  if (config.provider !== undefined
+    && (!config.provider || typeof config.provider !== 'object' || Array.isArray(config.provider))) {
+    return { configured: false, changed: false, conflict: true, file, reason: 'provider-invalid' };
+  }
+  if (!config.provider) config.provider = {};
+
+  let changed = false;
+  for (const { id, suffix } of OPENCODE_ROUTES) {
+    const target = `${origin}${suffix}`;
+    const entry = config.provider[id];
+    if (entry !== undefined && (!entry || typeof entry !== 'object' || Array.isArray(entry))) {
+      return { configured: false, changed: false, conflict: true, file, reason: `provider-${id}-invalid` };
+    }
+    const options = entry?.options;
+    if (options !== undefined && (!options || typeof options !== 'object' || Array.isArray(options))) {
+      return { configured: false, changed: false, conflict: true, file, reason: `options-${id}-invalid` };
+    }
+    const existing = options?.baseURL;
+    // Une base tierce délibérément posée par l'utilisateur n'est pas écrasée :
+    // on signale le conflit plutôt que de casser sa configuration en silence.
+    if (existing && existing !== target && !isOwnLoopbackUrl(existing, suffix)) {
+      return { configured: false, changed: false, conflict: true, file, reason: `base-url-conflict:${id}` };
+    }
+    if (existing === target) continue;
+    config.provider[id] = { ...entry, options: { ...options, baseURL: target } };
+    changed = true;
+  }
+
+  if (changed) writeJsonAtomic(file, config);
+  return { configured: true, changed, conflict: false, file };
+}
+
+function bypassOpencode({ userHome }) {
+  const file = opencodeConfigFile(userHome);
+  if (!fs.existsSync(file)) return { bypassed: true, changed: false, conflict: false, file };
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('objet JSON attendu');
+  } catch {
+    return { bypassed: false, changed: false, conflict: true, file, reason: 'config-invalid' };
+  }
+
+  let changed = false;
+  for (const { id, suffix } of OPENCODE_ROUTES) {
+    const options = config.provider?.[id]?.options;
+    if (!options || typeof options !== 'object' || Array.isArray(options)) continue;
+    if (!isOwnLoopbackUrl(options.baseURL, suffix)) continue;
+    delete options.baseURL;
+    if (Object.keys(options).length === 0) delete config.provider[id].options;
+    if (Object.keys(config.provider[id]).length === 0) delete config.provider[id];
+    changed = true;
+  }
+  if (changed && config.provider && Object.keys(config.provider).length === 0) delete config.provider;
+  if (changed) writeJsonAtomic(file, config);
+  return { bypassed: true, changed, conflict: false, file };
+}
+
+/** Première ligne du garde-fou Cursor : ce que le shim écrit avant de renoncer. */
+const CURSOR_REFUSAL = 'PieceMaker : cursor-agent ne peut pas être filtré par le proxy d’anonymisation '
+  + '(son protocole n’accepte aucune base d’URL). Tant qu’un mapping existe, il est bloqué pour éviter '
+  + 'que des noms de parties quittent la machine en clair. Utilisez Claude, Codex ou opencode.';
+
+/**
+ * Écrit le shim `cursor-agent` dans un répertoire que le service place en tête
+ * de `PATH`. Le shim ne lit jamais le contenu du mapping — sa seule existence
+ * décide —, et se retire du `PATH` avant de relayer le vrai binaire pour ne pas
+ * se rappeler lui-même.
+ */
+function installCursorGuard({ binDir, mappingFile }) {
+  fs.mkdirSync(binDir, { recursive: true });
+  const file = path.join(binDir, 'cursor-agent');
+  const script = `#!/bin/sh
+# Généré par PieceMaker — ne pas modifier. Voir server/piecemaker/anonymizer/providers.cjs
+if [ -s ${JSON.stringify(mappingFile)} ]; then
+  printf '%s\\n' ${JSON.stringify(CURSOR_REFUSAL)} >&2
+  exit 78
+fi
+PATH=$(printf '%s' "$PATH" | sed -e "s|^${binDir.replace(/[|\\]/g, '\\$&')}:||")
+export PATH
+exec cursor-agent "$@"
+`;
+  fs.writeFileSync(file, script, { encoding: 'utf8', mode: 0o755 });
+  return { file, binDir };
+}
+
+/**
+ * Câble tous les fournisseurs sur `origin` et rend un rapport par client.
+ * Aucun échec n'est fatal : un client mal configuré est signalé « non couvert »
+ * dans le statut, ce qui est l'information utile, plutôt que d'empêcher le
+ * serveur de démarrer.
+ */
+async function configureProviders({ origin, userHome = os.homedir(), binDir, mappingFile }) {
+  const report = {};
+
+  const attempt = (name, run) => {
+    try {
+      report[name] = run();
+    } catch (error) {
+      report[name] = { configured: false, changed: false, conflict: true, reason: error.message };
+    }
+  };
+
+  attempt('claude', () => configureClaudeCodeProxy({ baseUrl: `${origin}/anthropic`, userHome }));
+  attempt('codex', () => configureCodexProxy({
+    baseUrl: `${origin}/chatgpt`,
+    codexHome: process.env.CODEX_HOME || path.join(userHome, '.codex'),
+  }));
+  attempt('opencode', () => configureOpencode({ origin, userHome }));
+  attempt('cursor', () => ({
+    configured: false,
+    changed: false,
+    conflict: false,
+    blocked: true,
+    reason: 'not-interceptable',
+    ...installCursorGuard({ binDir, mappingFile }),
+  }));
+
+  return report;
+}
+
+/** Défait tout ce que `configureProviders` a posé : l'arrêt du serveur ne doit pas laisser de base morte. */
+async function bypassProviders({ userHome = os.homedir(), binDir }) {
+  const report = {};
+  const attempt = (name, run) => {
+    try {
+      report[name] = run();
+    } catch (error) {
+      report[name] = { bypassed: false, conflict: true, reason: error.message };
+    }
+  };
+
+  attempt('claude', () => bypassClaudeCodeProxy({ userHome }));
+  attempt('codex', () => bypassCodexProxy({ codexHome: process.env.CODEX_HOME || path.join(userHome, '.codex') }));
+  attempt('opencode', () => bypassOpencode({ userHome }));
+  attempt('cursor', () => {
+    const file = path.join(binDir, 'cursor-agent');
+    if (fs.existsSync(file)) fs.rmSync(file);
+    return { bypassed: true, file };
+  });
+  return report;
+}
+
+module.exports = {
+  CURSOR_REFUSAL,
+  OPENCODE_ROUTES,
+  bypassOpencode,
+  bypassProviders,
+  configureOpencode,
+  configureProviders,
+  installCursorGuard,
+  isOwnLoopbackUrl,
+  opencodeConfigFile,
+};