@piecemaker-legal/piecemaker 1.1.1 → 2.0.2

package/server/piecemaker/anonymizer/providers.cjs

@@ -1,30 +1,11 @@
 /**
- * Branchement des quatre clients IA de CloudCLI sur le proxy PII.
+ * Branchement des clients IA sur le proxy d'anonymisation.
  *
- * 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.
+ * Le serveur pose `HTTPS_PROXY` et le certificat de l'autorité locale.
+ * Les URL des fournisseurs ne sont pas réécrites.
  *
- *  | 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`.
+ * Cursor ignore tout proxy HTTP. Tant qu'un mapping existe, un shim en tête
+ * de `PATH` refuse de lancer `cursor-agent`.
  */
 const fs = require('node:fs');
 const os = require('node:os');
@@ -37,110 +18,12 @@ const {
   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 configureOpencode() {
+  return { configured: true, changed: false, conflict: false, file: null };
 }
 
-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 };
+function bypassOpencode() {
+  return { bypassed: true, changed: false, conflict: false, file: null };
 }
 
 /** Première ligne du garde-fou Cursor : ce que le shim écrit avant de renoncer. */
@@ -177,7 +60,7 @@ exec cursor-agent "$@"
  * 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 }) {
+async function configureProviders({ origin, caFile, userHome = os.homedir(), binDir, mappingFile }) {
   const report = {};
 
   const attempt = (name, run) => {
@@ -188,12 +71,11 @@ async function configureProviders({ origin, userHome = os.homedir(), binDir, map
     }
   };
 
-  attempt('claude', () => configureClaudeCodeProxy({ baseUrl: `${origin}/anthropic`, userHome }));
+  attempt('claude', () => configureClaudeCodeProxy({ proxyUrl: origin, caFile, userHome }));
   attempt('codex', () => configureCodexProxy({
-    baseUrl: `${origin}/chatgpt`,
     codexHome: process.env.CODEX_HOME || path.join(userHome, '.codex'),
   }));
-  attempt('opencode', () => configureOpencode({ origin, userHome }));
+  attempt('opencode', () => configureOpencode());
   attempt('cursor', () => ({
     configured: false,
     changed: false,
@@ -218,8 +100,8 @@ async function bypassProviders({ userHome = os.homedir(), binDir }) {
   };
 
   attempt('claude', () => bypassClaudeCodeProxy({ userHome }));
-  attempt('codex', () => bypassCodexProxy({ codexHome: process.env.CODEX_HOME || path.join(userHome, '.codex') }));
-  attempt('opencode', () => bypassOpencode({ userHome }));
+  attempt('codex', () => bypassCodexProxy());
+  attempt('opencode', () => bypassOpencode());
   attempt('cursor', () => {
     const file = path.join(binDir, 'cursor-agent');
     if (fs.existsSync(file)) fs.rmSync(file);
@@ -230,12 +112,9 @@ async function bypassProviders({ userHome = os.homedir(), binDir }) {
 
 module.exports = {
   CURSOR_REFUSAL,
-  OPENCODE_ROUTES,
   bypassOpencode,
   bypassProviders,
   configureOpencode,
   configureProviders,
   installCursorGuard,
-  isOwnLoopbackUrl,
-  opencodeConfigFile,
 };

package/server/piecemaker/anonymizer/rewriter-bridge.cjs

@@ -0,0 +1,221 @@
+const http = require('node:http');
+
+const { anonymize, deanonymize } = require('./dictionary.cjs');
+const { createSseRewriter, rewriteJsonBody } = require('./rewrite.cjs');
+const { createCollecteurTexte } = require('../harness/flux-sse.cjs');
+
+const MAX_BODY = 64 * 1024 * 1024;
+
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    request.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY) {
+        reject(new Error('corps trop volumineux'));
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on('end', () => resolve(Buffer.concat(chunks)));
+    request.on('error', reject);
+  });
+}
+
+function header(request, name) {
+  const value = request.headers[name];
+  return Array.isArray(value) ? value[0] : value || '';
+}
+
+function observeRequest(harness, body, contentType, provider) {
+  if (!harness) return;
+  try {
+    harness.observerRequete(body, contentType, { session: provider });
+  } catch {
+    // une observation ne doit pas empêcher le relais
+  }
+}
+
+function observeResponse(harness, text, provider) {
+  if (!harness) return;
+  try {
+    Promise.resolve(harness.observerReponse(text, { session: provider })).catch(() => {});
+  } catch {
+    // une observation ne doit pas empêcher le relais
+  }
+}
+
+function assistantText(raw) {
+  try {
+    const parsed = JSON.parse(raw.toString('utf8'));
+    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('');
+    }
+  } catch {
+    return '';
+  }
+  return '';
+}
+
+function ssePayloads(tail) {
+  return String(tail || '')
+    .split('\n')
+    .filter((line) => line.startsWith('data: '))
+    .map((line) => line.slice(6))
+    .filter((line) => line && line !== '[DONE]');
+}
+
+function startRewriterBridge({ dictionary, harness = null }) {
+  const sessions = new Map();
+  const stats = { requests: 0, anonymized: 0, deanonymized: 0, failures: 0, lastError: null };
+
+  const server = http.createServer((request, response) => {
+    const provider = header(request, 'x-piecemaker-provider') || 'claude';
+    const current = () => dictionary.get();
+
+    if (request.method === 'POST' && request.url === '/v1/request') {
+      readBody(request).then((body) => {
+        stats.requests += 1;
+        const contentType = header(request, 'content-type') || 'application/json';
+        observeRequest(harness, body, contentType, provider);
+        const dict = current();
+        const rewritten = !body.length || dict.empty
+          ? body
+          : Buffer.from(rewriteJsonBody(body, (text) => anonymize(text, dict)), 'utf8');
+        if (!rewritten.equals(body)) stats.anonymized += 1;
+        response.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': rewritten.length });
+        response.end(rewritten);
+      }).catch((error) => {
+        stats.failures += 1;
+        stats.lastError = error.message;
+        response.writeHead(500);
+        response.end();
+      });
+      return;
+    }
+
+    if (request.method === 'POST' && request.url === '/v1/response') {
+      readBody(request).then((body) => {
+        const dict = current();
+        const rewritten = !body.length || dict.empty
+          ? body
+          : Buffer.from(rewriteJsonBody(body, (text) => deanonymize(text, dict)), 'utf8');
+        if (!rewritten.equals(body)) stats.deanonymized += 1;
+        observeResponse(harness, assistantText(rewritten), provider);
+        response.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': rewritten.length });
+        response.end(rewritten);
+      }).catch((error) => {
+        stats.failures += 1;
+        stats.lastError = error.message;
+        response.writeHead(500);
+        response.end();
+      });
+      return;
+    }
+
+    if (request.method === 'POST' && request.url === '/v1/sse') {
+      const dict = current();
+      const rewriter = createSseRewriter((text) => deanonymize(text, dict));
+      const collecteur = createCollecteurTexte();
+      response.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+      });
+      response.flushHeaders();
+      request.setEncoding('utf8');
+      request.on('data', (chunk) => {
+        const out = rewriter.push(chunk);
+        if (!out) return;
+        response.write(out);
+        collecteur.push(out);
+      });
+      request.on('end', () => {
+        const tail = rewriter.end();
+        if (tail) {
+          response.write(tail);
+          collecteur.push(tail);
+        }
+        stats.deanonymized += 1;
+        response.end();
+        observeResponse(harness, collecteur.texte(), provider);
+      });
+      request.on('error', () => response.end());
+      return;
+    }
+
+    if (request.method === 'POST' && request.url === '/v1/ws') {
+      const id = header(request, 'x-piecemaker-ws');
+      const direction = header(request, 'x-piecemaker-direction');
+      readBody(request).then((body) => {
+        const dict = current();
+        const text = body.toString('utf8');
+        if (direction === 'out') {
+          observeRequest(harness, body, 'application/json', provider);
+          const rewritten = dict.empty ? text : rewriteJsonBody(text, (value) => anonymize(value, dict));
+          response.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+          response.end(rewritten);
+          return;
+        }
+        let entry = sessions.get(id);
+        if (!entry) {
+          entry = { rewriter: createSseRewriter((value) => deanonymize(value, dict)) };
+          sessions.set(id, entry);
+        }
+        if (!text.includes('\n')) {
+          const payloads = ssePayloads(entry.rewriter.push(`data: ${text}\n\n`));
+          response.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+          response.end(payloads.join('\n'));
+          return;
+        }
+        const rewritten = dict.empty ? text : rewriteJsonBody(text, (value) => deanonymize(value, dict));
+        response.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+        response.end(rewritten);
+      }).catch(() => {
+        response.writeHead(500);
+        response.end();
+      });
+      return;
+    }
+
+    if (request.method === 'POST' && request.url === '/v1/ws-end') {
+      const id = header(request, 'x-piecemaker-ws');
+      const entry = sessions.get(id);
+      sessions.delete(id);
+      const messages = entry ? ssePayloads(entry.rewriter.end()) : [];
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ messages }));
+      return;
+    }
+
+    response.writeHead(404);
+    response.end();
+  });
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      resolve({
+        port,
+        stats,
+        close() {
+          return new Promise((done) => server.close(() => done()));
+        },
+      });
+    });
+  });
+}
+
+module.exports = { startRewriterBridge };

package/server/piecemaker/anonymizer/service.cjs

@@ -15,17 +15,24 @@
  * Le proxy vit et meurt avec le serveur : à l'arrêt, les bases écrites sont
  * retirées pour ne pas laisser les clients pointer un port fermé.
  */
+const { spawn } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
 const { createSqliteDictionaryLoader } = require('./sqlite-dictionary.cjs');
-const { DEFAULT_UPSTREAM, createAnonymizerProxy } = require('./proxy.cjs');
+const { startRewriterBridge } = require('./rewriter-bridge.cjs');
 const { bypassProviders, configureProviders } = require('./providers.cjs');
 const { createHarnessJuridique } = require('../harness/index.cjs');
 
 const ENV_VAR = 'ANTHROPIC_BASE_URL';
 const OPENAI_ENV_VAR = 'OPENAI_BASE_URL';
+const DEFAULT_UPSTREAM = 'https://api.anthropic.com';
+const DEFAULT_PORT = 4111;
+const PROXY_ENV_KEYS = [
+  'HTTPS_PROXY', 'HTTP_PROXY', 'ALL_PROXY', 'NO_PROXY', 'NODE_USE_ENV_PROXY',
+  'NODE_EXTRA_CA_CERTS', 'SSL_CERT_FILE', 'CODEX_CA_CERTIFICATE', 'REQUESTS_CA_BUNDLE',
+];
 
 /** Interrupteur : `PIECEMAKER_ANONYMIZER=off`, ou `anonymizer.enabled: false` dans `config.json`. */
 function isDisabled(homeDir) {
@@ -76,6 +83,66 @@ function summarizeCoverage(report) {
   return coverage;
 }
 
+function hudsuckerBinary() {
+  if (process.env.PIECEMAKER_HUDSUCKER_BIN) return process.env.PIECEMAKER_HUDSUCKER_BIN;
+  const name = process.platform === 'win32' ? 'piecemaker-hudsucker.exe' : 'piecemaker-hudsucker';
+  const packaged = path.join(__dirname, 'bin', name);
+  const release = path.join(__dirname, 'hudsucker-proxy', 'target', 'release', name);
+  const debug = path.join(__dirname, 'hudsucker-proxy', 'target', 'debug', name);
+  if (fs.existsSync(packaged)) return packaged;
+  if (fs.existsSync(release)) return release;
+  if (fs.existsSync(debug)) return debug;
+  return packaged;
+}
+
+function certificatePaths() {
+  const directory = path.join(os.homedir(), '.piecemaker', 'certs');
+  return {
+    cert: path.join(directory, 'piecemaker-ca.crt'),
+    key: path.join(directory, 'piecemaker-ca.key'),
+  };
+}
+
+function waitForOutput(child, needle, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let buffer = '';
+    let settled = false;
+    const finish = (failed, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.stdout?.off('data', take);
+      child.stderr?.off('data', take);
+      child.off('exit', onExit);
+      if (failed) reject(value);
+      else resolve(value);
+    };
+    const timer = setTimeout(() => finish(true, new Error(`hudsucker n'a pas écouté : ${buffer}`)), timeoutMs);
+    const take = (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.includes(needle)) finish(false, buffer);
+    };
+    const onExit = (code) => finish(true, new Error(`hudsucker sorti (${code}) : ${buffer}`));
+    child.stdout?.on('data', take);
+    child.stderr?.on('data', take);
+    child.once('exit', onExit);
+  });
+}
+
+function proxyEnvironment(proxyUrl, caFile) {
+  return {
+    HTTPS_PROXY: proxyUrl,
+    HTTP_PROXY: proxyUrl,
+    ALL_PROXY: proxyUrl,
+    NO_PROXY: 'localhost,127.0.0.1,::1',
+    NODE_USE_ENV_PROXY: '1',
+    NODE_EXTRA_CA_CERTS: caFile,
+    SSL_CERT_FILE: caFile,
+    CODEX_CA_CERTIFICATE: caFile,
+    REQUESTS_CA_BUNDLE: caFile,
+  };
+}
+
 function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = console, required = false }) {
   const dictionary = createSqliteDictionaryLoader({ databasePath: process.env.DATABASE_PATH || path.join(homeDir, 'auth.db') });
   const legacyMappingFile = path.join(homeDir, 'central-mapping.json');
@@ -96,6 +163,7 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
     coverage: {},
   };
   let proxy = null;
+  let bridge = null;
   let previousEnv = null;
 
   async function start() {
@@ -105,34 +173,68 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       return state;
     }
 
+    const binary = hudsuckerBinary();
+    const certificates = certificatePaths();
+    if (!fs.existsSync(binary) || !fs.existsSync(certificates.cert) || !fs.existsSync(certificates.key)) {
+      state.reason = 'binary_or_ca_missing';
+      logger.warn?.('[piecemaker] hudsucker ou autorité locale absent');
+      return state;
+    }
+
     const claudeUpstream = resolveUpstream(process.env[ENV_VAR]);
-    proxy = createAnonymizerProxy({
-      dictionary,
-      routes: [
-        { provider: 'claude', prefix: '/anthropic', upstream: claudeUpstream },
-        { provider: 'codex', prefix: '/chatgpt', upstream: 'https://chatgpt.com/backend-api/codex' },
-        { provider: 'opencode', prefix: '/openai', upstream: 'https://api.openai.com' },
-      ],
-      harness,
-      onError: (error) => logger.warn?.(`[piecemaker] proxy PII : ${error.message}`),
-    });
+    const hosts = ['api.anthropic.com', 'api.openai.com', 'chatgpt.com'];
+    try {
+      const extra = new URL(claudeUpstream).hostname;
+      if (extra && !hosts.includes(extra)) hosts.push(extra);
+    } catch {
+      // l'amont par défaut reste la liste fixe
+    }
+
+    try {
+      bridge = await startRewriterBridge({ dictionary, harness });
+    } catch (error) {
+      state.reason = `listen_failed: ${error.message}`;
+      logger.warn?.(`[piecemaker] réécriture PII non démarrée : ${error.message}`);
+      return state;
+    }
 
-    let origin;
-    let listenedPort;
+    const listenedPort = DEFAULT_PORT;
+    const origin = `http://127.0.0.1:${listenedPort}`;
+    const child = spawn(binary, [
+      '--listen', `127.0.0.1:${listenedPort}`,
+      '--rewriter', `http://127.0.0.1:${bridge.port}`,
+      '--ca-cert', certificates.cert,
+      '--ca-key', certificates.key,
+      '--hosts', hosts.join(','),
+    ], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        HTTPS_PROXY: '',
+        HTTP_PROXY: '',
+        ALL_PROXY: '',
+        https_proxy: '',
+        http_proxy: '',
+        all_proxy: '',
+      },
+    });
+    proxy = child;
+    child.stdout?.on('data', (chunk) => logger.log?.(String(chunk).trim()));
+    child.stderr?.on('data', (chunk) => logger.warn?.(`[piecemaker] hudsucker : ${String(chunk).trim()}`));
     try {
-      ({ origin, port: listenedPort } = await proxy.listen());
+      await waitForOutput(child, `listening 127.0.0.1:${listenedPort}`, 15000);
     } catch (error) {
+      child.kill('SIGKILL');
       proxy = null;
+      await bridge.close();
+      bridge = null;
       state.reason = `listen_failed: ${error.message}`;
       logger.warn?.(`[piecemaker] proxy PII non démarré : ${error.message}`);
       return state;
     }
 
-    // Publie le port réellement obtenu (le scan de proxy.cjs peut dévier du
-    // port préféré si une instance précédente n'a pas encore libéré le sien)
-    // dans la config partagée, pour que d'autres consommateurs indépendants
-    // du process serveur (ex. le sous-service Docker "mike") puissent le
-    // retrouver sans le redéduire eux-mêmes ni le coder en dur.
+    // Publie le port dans la config partagée pour que les consommateurs
+    // indépendants du process serveur puissent le retrouver.
     try {
       const configFile = path.join(homeDir, 'config.json');
       const current = JSON.parse(fs.readFileSync(configFile, 'utf8'));
@@ -148,19 +250,24 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       [OPENAI_ENV_VAR]: process.env[OPENAI_ENV_VAR],
       PATH: process.env.PATH,
     };
-    process.env[ENV_VAR] = `${origin}/anthropic`;
-    process.env[OPENAI_ENV_VAR] = `${origin}/openai`;
-    // En tête de chemin : le shim doit être trouvé avant le vrai `cursor-agent`.
+    for (const key of PROXY_ENV_KEYS) previousEnv[key] = process.env[key];
+    Object.assign(process.env, proxyEnvironment(origin, certificates.cert));
     process.env.PATH = `${binDir}${path.delimiter}${process.env.PATH || ''}`;
 
-    const report = await configureProviders({ origin, userHome, binDir, mappingFile: legacyMappingFile });
+    const report = await configureProviders({
+      origin,
+      caFile: certificates.cert,
+      userHome,
+      binDir,
+      mappingFile: legacyMappingFile,
+    });
     Object.assign(state, {
       enabled: true,
       reason: 'running',
       origin,
       upstream: claudeUpstream,
       startedAt: new Date().toISOString(),
-      routes: proxy.routes,
+      routes: hosts.map((host) => ({ provider: host, upstream: `https://${host}` })),
       coverage: summarizeCoverage(report),
     });
 
@@ -175,11 +282,20 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
   }
 
   async function stop() {
-    if (!proxy) {
+    if (!proxy && !bridge) {
       dictionary.close();
       return;
     }
-    await proxy.close();
+    if (proxy && proxy.exitCode === null) {
+      proxy.kill('SIGTERM');
+      await Promise.race([
+        new Promise((resolve) => proxy.once('exit', resolve)),
+        new Promise((resolve) => setTimeout(resolve, 2000)),
+      ]);
+      if (proxy.exitCode === null) proxy.kill('SIGKILL');
+    }
+    if (bridge) await bridge.close();
+    bridge = null;
     await bypassProviders({ userHome, binDir });
     if (previousEnv) {
       for (const [key, value] of Object.entries(previousEnv)) {
@@ -197,7 +313,7 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
     const current = dictionary.get();
     return {
       ...state,
-      listening: Boolean(proxy?.listening),
+      listening: Boolean(proxy && proxy.exitCode === null && !proxy.killed),
       dictionary: {
         file: dictionary.file,
         exists: dictionary.exists(),
@@ -206,7 +322,7 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
         updatedAt: current.updatedAt,
         empty: current.empty,
       },
-      stats: proxy ? { ...proxy.stats } : null,
+      stats: bridge ? { ...bridge.stats } : null,
     };
   }