@piecemaker-legal/piecemaker 2.0.9 → 2.0.10

package/server/piecemaker/anonymizer/lifecycle.ts

@@ -1,15 +1,14 @@
 type AnonymizerService = {
   start(): Promise<unknown>;
   stop(): Promise<unknown>;
-  status(): { enabled: boolean; listening: boolean; coverage: Record<string, { state: string }> };
+  status(): { enabled: boolean; listening: boolean; reason?: string };
 };
 
 export async function startRequiredAnonymizer(service: AnonymizerService) {
   const ensureReady = () => {
     const status = service.status();
+    if (status.reason === 'disabled') return;
     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();

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

@@ -85,6 +85,12 @@ function startRewriterBridge({ dictionary, harness = null }) {
     const provider = header(request, 'x-piecemaker-provider') || 'claude';
     const current = () => dictionary.get();
 
+    if (request.method === 'GET' && request.url === '/health') {
+      response.writeHead(200);
+      response.end('ok');
+      return;
+    }
+
     if (request.method === 'POST' && request.url === '/v1/request') {
       readBody(request).then((body) => {
         stats.requests += 1;

package/server/piecemaker/anonymizer/service.cjs

@@ -1,20 +1,3 @@
-/**
- * Cycle de vie du proxy PII et point d'injection dans CloudCLI.
- *
- * Deux leviers, aucun ne touchant un fichier upstream.
- *
- * **L'environnement du serveur.** Les quatre chemins de lancement de CloudCLI —
- * chat Claude, Codex, Cursor, opencode — étalent `process.env` dans le
- * sous-processus qu'ils créent, tout comme le terminal intégré. Poser des
- * variables ici les atteint donc tous les cinq sans ajouter une ligne ailleurs.
- *
- * **Les configurations utilisateur des clients.** Codex ne lit pas de variable
- * de base d'URL, opencode préfère sa configuration ; `providers.cjs` s'en
- * charge, et pose le garde-fou de Cursor, seul client non interceptable.
- *
- * 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');
@@ -23,19 +6,22 @@ const tls = require('node:tls');
 
 const { createSqliteDictionaryLoader } = require('./sqlite-dictionary.cjs');
 const { startRewriterBridge } = require('./rewriter-bridge.cjs');
-const { bypassProviders, configureProviders } = require('./providers.cjs');
+const { removeLegacyProxyConfig } = require('./client-config.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',
-];
+const INTERCEPTED_HOSTS = ['api.anthropic.com', 'api.openai.com', 'chatgpt.com'];
+const COVERAGE = {
+  claude: { state: 'filtered', detail: null, file: null },
+  codex: { state: 'filtered', detail: null, file: null },
+  opencode: { state: 'filtered', detail: null, file: null },
+  cursor: { state: 'blocked', detail: 'not-interceptable', file: null },
+};
+
+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.';
 
-/** Interrupteur : `PIECEMAKER_ANONYMIZER=off`, ou `anonymizer.enabled: false` dans `config.json`. */
 function isDisabled(homeDir) {
   const flag = String(process.env.PIECEMAKER_ANONYMIZER || '').toLowerCase();
   if (flag === 'off' || flag === '0' || flag === 'false') return true;
@@ -47,13 +33,6 @@ function isDisabled(homeDir) {
   }
 }
 
-/**
- * Cible du relais Anthropic. Une base distante déjà configurée (passerelle
- * d'entreprise, point de terminaison alternatif) est respectée : on se chaîne
- * derrière elle. Une base en boucle locale ne peut être qu'une instance
- * précédente de ce proxy, et serait un relais mort : on l'ignore au profit de
- * l'API officielle.
- */
 function resolveUpstream(configured) {
   if (!configured) return DEFAULT_UPSTREAM;
   try {
@@ -65,35 +44,15 @@ function resolveUpstream(configured) {
   }
 }
 
-/**
- * Lecture du rapport de `configureProviders` en une couverture par client, la
- * seule chose que l'interface a besoin de montrer.
- *
- * `filtered` : les échanges passent par le proxy et sont anonymisés.
- * `blocked`  : le client ne peut pas être filtré et est donc empêché de partir.
- * `unconfigured` : le câblage a échoué ou est en conflit — le client peut
- * encore parler en direct, et c'est précisément ce que le statut doit crier.
- */
-function summarizeCoverage(report) {
-  const coverage = {};
-  for (const [name, result] of Object.entries(report || {})) {
-    if (result?.blocked) coverage[name] = { state: 'blocked', detail: result.reason, file: result.file || null };
-    else if (result?.configured) coverage[name] = { state: 'filtered', detail: null, file: result.file || null };
-    else coverage[name] = { state: 'unconfigured', detail: result?.reason || 'unknown', file: result?.file || null };
-  }
-  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;
+  const candidates = [
+    path.join(__dirname, 'bin', name),
+    path.join(__dirname, 'hudsucker-proxy', 'target', 'release', name),
+    path.join(__dirname, 'hudsucker-proxy', 'target', 'debug', name),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
 }
 
 function certificatePaths() {
@@ -113,28 +72,52 @@ function writeTrustBundle(caFile, bundleFile) {
   return bundleFile;
 }
 
-function waitForOutput(child, needle, timeoutMs) {
+function removeLegacyCentralMapping(homeDir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(homeDir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name.startsWith('central-mapping.json')) fs.rmSync(path.join(homeDir, name), { force: true });
+  }
+}
+
+function installCursorGuard({ binDir, mappingFile }) {
+  fs.mkdirSync(binDir, { recursive: true });
+  const file = path.join(binDir, 'cursor-agent');
+  const script = `#!/bin/sh
+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 };
+}
+
+function waitForListening(child, timeoutMs) {
   return new Promise((resolve, reject) => {
     let buffer = '';
-    let settled = false;
-    const finish = (failed, value) => {
-      if (settled) return;
-      settled = true;
+    const finish = (error, port) => {
       clearTimeout(timer);
-      child.stdout?.off('data', take);
-      child.stderr?.off('data', take);
+      child.stdout.off('data', take);
       child.off('exit', onExit);
-      if (failed) reject(value);
-      else resolve(value);
+      if (error) reject(error);
+      else resolve(port);
     };
-    const timer = setTimeout(() => finish(true, new Error(`hudsucker n'a pas écouté : ${buffer}`)), timeoutMs);
+    const timer = setTimeout(() => finish(new Error(`hudsucker n'a pas écouté : ${buffer}`)), timeoutMs);
     const take = (chunk) => {
       buffer += chunk.toString();
-      if (buffer.includes(needle)) finish(false, buffer);
+      const match = buffer.match(/listening 127\.0\.0\.1:(\d+)/);
+      if (match) finish(null, Number(match[1]));
     };
-    const onExit = (code) => finish(true, new Error(`hudsucker sorti (${code}) : ${buffer}`));
-    child.stdout?.on('data', take);
-    child.stderr?.on('data', take);
+    const onExit = (code) => finish(new Error(`hudsucker sorti (${code}) : ${buffer}`));
+    child.stdout.on('data', take);
     child.once('exit', onExit);
   });
 }
@@ -142,8 +125,7 @@ function waitForOutput(child, needle, timeoutMs) {
 function proxyEnvironment(proxyUrl, caFile, trustBundle) {
   return {
     HTTPS_PROXY: proxyUrl,
-    HTTP_PROXY: proxyUrl,
-    ALL_PROXY: proxyUrl,
+    https_proxy: proxyUrl,
     NO_PROXY: 'localhost,127.0.0.1,::1',
     NODE_USE_ENV_PROXY: '1',
     NODE_EXTRA_CA_CERTS: caFile,
@@ -153,32 +135,20 @@ function proxyEnvironment(proxyUrl, caFile, trustBundle) {
   };
 }
 
-function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = console, required = false }) {
+function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = console }) {
   const dictionary = createSqliteDictionaryLoader({ databasePath: process.env.DATABASE_PATH || path.join(homeDir, 'auth.db') });
-  const legacyMappingFile = path.join(homeDir, 'central-mapping.json');
-  // Harnais de citations vérifiées (décisions Légifrance + bloc <CITATIONS>) :
-  // son propre interrupteur (`PIECEMAKER_CITATIONS=off`) est géré à
-  // l'intérieur, pas ici.
   const harness = createHarnessJuridique({ homeDir, verifyResponses: false });
-  // Le shim Cursor vit sous le répertoire de données PieceMaker : il n'a rien à
-  // faire dans un répertoire appartenant à un fournisseur.
   const binDir = path.join(homeDir, 'bin');
-  const state = {
-    enabled: false,
-    reason: 'not_started',
-    origin: null,
-    upstream: null,
-    startedAt: null,
-    routes: [],
-    coverage: {},
-  };
+  const state = { enabled: false, reason: 'not_started', origin: null, upstream: null, coverage: {} };
   let proxy = null;
   let bridge = null;
   let previousEnv = null;
+  const killProxy = () => proxy?.kill('SIGKILL');
 
   async function start() {
     if (proxy) return state;
-    if (!required && isDisabled(homeDir)) {
+    removeLegacyProxyConfig({ userHome, homeDir });
+    if (isDisabled(homeDir)) {
       state.reason = 'disabled';
       return state;
     }
@@ -191,14 +161,8 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       return state;
     }
 
-    const claudeUpstream = resolveUpstream(process.env[ENV_VAR]);
-    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
-    }
+    const upstream = resolveUpstream(process.env.ANTHROPIC_BASE_URL);
+    const hosts = [...new Set([...INTERCEPTED_HOSTS, new URL(upstream).hostname])];
 
     try {
       bridge = await startRewriterBridge({ dictionary, harness });
@@ -208,33 +172,30 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       return state;
     }
 
-    const listenedPort = DEFAULT_PORT;
-    const origin = `http://127.0.0.1:${listenedPort}`;
     const child = spawn(binary, [
-      '--listen', `127.0.0.1:${listenedPort}`,
+      '--listen', '127.0.0.1:0',
       '--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: '',
-      },
+      stdio: ['pipe', '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()}`));
+    process.once('exit', killProxy);
+    child.stderr.on('data', (chunk) => logger.warn?.(`[piecemaker] hudsucker : ${String(chunk).trim()}`));
+    child.once('exit', (code, signal) => {
+      if (proxy === child && state.enabled) logger.warn?.(`[piecemaker] hudsucker arrêté (${code ?? signal}) : requêtes IA refusées`);
+    });
+
+    let port;
     try {
-      await waitForOutput(child, `listening 127.0.0.1:${listenedPort}`, 15000);
+      port = await waitForListening(child, 15000);
+      child.stdout.resume();
     } catch (error) {
       child.kill('SIGKILL');
+      process.off('exit', killProxy);
       proxy = null;
       await bridge.close();
       bridge = null;
@@ -243,72 +204,44 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       return state;
     }
 
-    // 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'));
-      if (current.mikePiiPort !== listenedPort) {
-        fs.writeFileSync(configFile, `${JSON.stringify({ ...current, mikePiiPort: listenedPort }, null, 2)}\n`, 'utf8');
-      }
-    } catch (error) {
-      logger.warn?.(`[piecemaker] impossible de publier mikePiiPort dans config.json : ${error.message}`);
-    }
-
-    previousEnv = {
-      [ENV_VAR]: process.env[ENV_VAR],
-      [OPENAI_ENV_VAR]: process.env[OPENAI_ENV_VAR],
-      PATH: process.env.PATH,
-    };
-    for (const key of PROXY_ENV_KEYS) previousEnv[key] = process.env[key];
-    const trustBundle = writeTrustBundle(certificates.cert, certificates.trustBundle);
-    Object.assign(process.env, proxyEnvironment(origin, certificates.cert, trustBundle));
+    const origin = `http://127.0.0.1:${port}`;
+    const environment = proxyEnvironment(origin, certificates.cert, writeTrustBundle(certificates.cert, certificates.trustBundle));
+    previousEnv = Object.fromEntries(['PATH', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy', ...Object.keys(environment)]
+      .map((key) => [key, process.env[key]]));
+    for (const key of ['HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete process.env[key];
+    Object.assign(process.env, environment);
+    removeLegacyCentralMapping(homeDir);
+    installCursorGuard({ binDir, mappingFile: path.join(homeDir, 'central-mapping.json') });
     process.env.PATH = `${binDir}${path.delimiter}${process.env.PATH || ''}`;
 
-    const report = await configureProviders({
-      origin,
-      caFile: certificates.cert,
-      trustBundle,
-      userHome,
-      binDir,
-      mappingFile: legacyMappingFile,
-    });
     Object.assign(state, {
       enabled: true,
       reason: 'running',
       origin,
-      upstream: claudeUpstream,
-      startedAt: new Date().toISOString(),
-      routes: hosts.map((host) => ({ provider: host, upstream: `https://${host}` })),
-      coverage: summarizeCoverage(report),
+      upstream,
+      coverage: COVERAGE,
     });
-
-    const uncovered = Object.entries(state.coverage)
-      .filter(([, value]) => value.state === 'unconfigured')
-      .map(([name]) => name);
     logger.log?.(`[piecemaker] anonymisation active sur ${origin} (claude, codex, opencode ; cursor bloqué)`);
-    if (uncovered.length) {
-      logger.warn?.(`[piecemaker] clients non filtrés, à vérifier : ${uncovered.join(', ')}`);
-    }
     return state;
   }
 
   async function stop() {
-    if (!proxy && !bridge) {
-      dictionary.close();
-      return;
-    }
-    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 (proxy) {
+      const child = proxy;
+      proxy = null;
+      process.off('exit', killProxy);
+      if (child.exitCode === null) {
+        child.kill('SIGTERM');
+        await Promise.race([
+          new Promise((resolve) => child.once('exit', resolve)),
+          new Promise((resolve) => setTimeout(resolve, 2000)),
+        ]);
+        if (child.exitCode === null) child.kill('SIGKILL');
+      }
     }
     if (bridge) await bridge.close();
     bridge = null;
-    await bypassProviders({ userHome, binDir });
+    fs.rmSync(path.join(binDir, 'cursor-agent'), { force: true });
     if (previousEnv) {
       for (const [key, value] of Object.entries(previousEnv)) {
         if (value === undefined) delete process.env[key];
@@ -316,16 +249,15 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
       }
       previousEnv = null;
     }
-    proxy = null;
     dictionary.close();
-    Object.assign(state, { enabled: false, reason: 'stopped', origin: null, routes: [], coverage: {} });
+    Object.assign(state, { enabled: false, reason: 'stopped', origin: null, upstream: null, coverage: {} });
   }
 
   function status() {
     const current = dictionary.get();
     return {
       ...state,
-      listening: Boolean(proxy && proxy.exitCode === null && !proxy.killed),
+      listening: Boolean(proxy && proxy.exitCode === null && proxy.signalCode === null),
       dictionary: {
         file: dictionary.file,
         exists: dictionary.exists(),
@@ -342,11 +274,8 @@ function createAnonymizerService({ homeDir, userHome = os.homedir(), logger = co
 }
 
 module.exports = {
-  ENV_VAR,
-  OPENAI_ENV_VAR,
   createAnonymizerService,
-  isDisabled,
+  installCursorGuard,
   resolveUpstream,
-  summarizeCoverage,
   writeTrustBundle,
 };

package/server/piecemaker/docx-document.ts

@@ -0,0 +1,54 @@
+import { randomUUID } from 'crypto';
+import { rename, rm, stat, writeFile } from 'fs/promises';
+import path from 'path';
+
+import express, { type Request, type Response } from 'express';
+
+import { projectsDb } from '@/modules/database/index.js';
+
+const MAX_DOCX_BYTES = '100mb';
+
+function resolveDocxPath(request: Request): string | null {
+  const projectId = typeof request.query.projectId === 'string' ? request.query.projectId : '';
+  const filePath = typeof request.query.path === 'string' ? request.query.path : '';
+  const projectRoot = projectId ? projectsDb.getProjectPathById(projectId) : null;
+  if (!projectRoot || !filePath.toLowerCase().endsWith('.docx')) return null;
+  const resolved = path.resolve(projectRoot, filePath);
+  return resolved.startsWith(path.resolve(projectRoot) + path.sep) ? resolved : null;
+}
+
+async function readVersion(filePath: string): Promise<number> {
+  return (await stat(filePath)).mtimeMs;
+}
+
+export function createDocxDocumentRouter() {
+  const router = express.Router();
+
+  router.get('/docx-document/version', async (request: Request, response: Response) => {
+    const filePath = resolveDocxPath(request);
+    if (!filePath) return response.status(400).json({ error: 'Invalid docx path' });
+    try {
+      response.json({ version: await readVersion(filePath) });
+    } catch {
+      response.status(404).json({ error: 'File not found' });
+    }
+  });
+
+  router.put('/docx-document', express.raw({ type: () => true, limit: MAX_DOCX_BYTES }), async (request: Request, response: Response) => {
+    const filePath = resolveDocxPath(request);
+    if (!filePath || !Buffer.isBuffer(request.body) || request.body.length === 0) {
+      return response.status(400).json({ error: 'Invalid docx payload' });
+    }
+    const temporaryPath = `${filePath}.${randomUUID()}.tmp`;
+    try {
+      await writeFile(temporaryPath, request.body);
+      await rename(temporaryPath, filePath);
+      response.json({ version: await readVersion(filePath) });
+    } catch (error) {
+      await rm(temporaryPath, { force: true });
+      response.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+
+  return router;
+}

package/server/piecemaker/harness/decisions.cjs

@@ -3,7 +3,7 @@
 /**
  * Capture des décisions Légifrance lues via l'outil MCP `consulter_decision`,
  * repérées dans un corps de requête SORTANTE déjà analysé en JSON par le
- * proxy PII (`server/piecemaker/anonymizer/proxy.cjs`).
+ * proxy PII (`server/piecemaker/anonymizer/rewriter-bridge.cjs`).
  *
  * Équivalent serveur du hook `decision-cache.mjs` de l'autre dépôt
  * (`piecemaker-plugin/scripts/decision-cache.mjs`, PostToolUse Claude Code) :

package/server/piecemaker/harness/index.cjs

@@ -1,9 +1,8 @@
 'use strict';
 
 /**
- * Façade du harnais de citations vérifiées, à brancher sur le proxy PII
- * local (`server/piecemaker/anonymizer/proxy.cjs`) — câblage laissé à une
- * tâche ultérieure, ce module ne modifie rien de `proxy.cjs`.
+ * Façade du harnais de citations vérifiées, branchée sur le réécrivain du
+ * proxy PII (`server/piecemaker/anonymizer/rewriter-bridge.cjs`).
  *
  * Deux observateurs, symétriques au sens et au retour du proxy lui-même :
  *  - `observerRequete` regarde ce qui PART vers le fournisseur (avant

package/server/piecemaker/harness/verification.cjs

@@ -6,7 +6,7 @@
  * (`piecemaker-plugin/scripts/verify-citations.mjs`).
  *
  * Ce dépôt n'a pas de hook Claude Code : tout le trafic IA passe par le
- * proxy PII local (`server/piecemaker/anonymizer/proxy.cjs`), qui est donc
+ * proxy PII local (`server/piecemaker/anonymizer/rewriter-bridge.cjs`), qui est donc
  * l'unique point d'observation possible pour un texte produit par le modèle.
  * Contrairement au hook d'origine, ce module n'a pas le pouvoir de bloquer
  * un tour (il n'y a pas de conversation Claude Code à interrompre côté

package/server/piecemaker/index.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import type { Router } from 'express';
 
 import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
 
 
@@ -16,7 +17,10 @@ import { createKnowledgeBackend } from './knowledge/index.js';
 import { createTimesheetBackend } from './timesheet/index.js';
 import { createCompanySearchRouter } from './company-search.js';
 import { createBodaccSearchRouter } from './bodacc-search.js';
+import { createDocxDocumentRouter } from './docx-document.js';
 import { createShellEnvironmentRouter, resolveDesktopShellEnvironment } from './shell-environment.js';
+import { installModelDiscovery } from './model-discovery/index.js';
+import { startProjectRegistry } from './project-registry.js';
 
 /**
  * Point d'entrée PieceMaker. Les modules de `server/piecemaker/vendor/` sont du
@@ -37,8 +41,9 @@ type PieceMakerRuntimeStatus = {
 };
 
 type PieceMakerVendorModule = {
-  createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown }): Router;
+  createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown; publishProjects?: () => void }): Router;
   piecemakerHome(): string;
+  publishProjectSource(sourceId: string, folders: string[] | null): void;
   stopOriginalsJobs(): Promise<void>;
 };
 
@@ -46,13 +51,15 @@ const shellEnvironment = await resolveDesktopShellEnvironment();
 const vendor = createRequire(import.meta.url)(routerPath) as PieceMakerVendorModule;
 
 export const { piecemakerHome, stopOriginalsJobs } = vendor;
+const publishProjects = startProjectRegistry(vendor.publishProjectSource);
 const { createAnonymizerService } = createRequire(import.meta.url)(path.join(applicationRoot, 'server/piecemaker/anonymizer/service.cjs'));
-const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required: true });
+const anonymizer = createAnonymizerService({ homeDir: piecemakerHome() });
 const ensureProxy = await startRequiredAnonymizer(anonymizer);
 const citations = createCitationStore(piecemakerHome());
 installChatCitationHarness({ runtime: providerRuntimeService, sessions: sessionsService, store: citations, ensureProxy });
 const library = await openLibrary(piecemakerHome(), applicationRoot);
 installLibraryRuntime(providerRuntimeService, sessionsService, library.store);
+installModelDiscovery(providerRegistry);
 const timesheet = createTimesheetBackend(piecemakerHome());
 const knowledge = createKnowledgeBackend(applicationRoot);
 
@@ -61,7 +68,7 @@ export function createPieceMakerLocalRouter() {
 }
 
 export function createPieceMakerRouter(options: { getRuntimeStatus?: () => PieceMakerRuntimeStatus } = {}) {
-  const router = vendor.createPieceMakerRouter({ ...options, anonymizer });
+  const router = vendor.createPieceMakerRouter({ ...options, anonymizer, publishProjects });
   router.use(createCitationsRouter(citations, (id) => {
     try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
   }));
@@ -70,6 +77,7 @@ export function createPieceMakerRouter(options: { getRuntimeStatus?: () => Piece
   router.use(knowledge.router);
   router.use(createCompanySearchRouter());
   router.use(createBodaccSearchRouter());
+  router.use(createDocxDocumentRouter());
   router.use(createShellEnvironmentRouter(shellEnvironment));
   return router;
 }

package/server/piecemaker/model-discovery/codex-catalog.ts

@@ -0,0 +1,67 @@
+import { createRequire } from 'node:module';
+
+import type { ProviderModelOption, ProviderModelsDefinition } from '@/shared/types.js';
+
+import { withStdioRpcServer, type RpcCall, type StdioRpcServer } from './stdio-rpc.js';
+
+type CodexListedModel = {
+  model: string;
+  displayName?: string;
+  description?: string;
+  hidden?: boolean;
+  isDefault?: boolean;
+  defaultReasoningEffort?: string;
+  supportedReasoningEfforts?: { reasoningEffort: string; description?: string }[];
+};
+
+type CodexModelListPage = {
+  data?: CodexListedModel[];
+  nextCursor?: string | null;
+};
+
+const MAX_PAGES = 10;
+
+function bundledCodexAppServer(): StdioRpcServer {
+  const launcher = createRequire(import.meta.url).resolve('@openai/codex/bin/codex.js');
+  return { command: process.execPath, args: [launcher, 'app-server'] };
+}
+
+function toModelOption(listed: CodexListedModel): ProviderModelOption {
+  const efforts = listed.supportedReasoningEfforts ?? [];
+  return {
+    value: listed.model,
+    label: listed.displayName || listed.model,
+    ...(listed.description ? { description: listed.description } : {}),
+    ...(efforts.length > 0 ? {
+      effort: {
+        ...(listed.defaultReasoningEffort ? { default: listed.defaultReasoningEffort } : {}),
+        values: efforts.map(({ reasoningEffort, description }) => ({
+          value: reasoningEffort,
+          ...(description ? { description } : {}),
+        })),
+      },
+    } : {}),
+  };
+}
+
+export async function listCodexModels(call: RpcCall): Promise<ProviderModelsDefinition> {
+  const listed: CodexListedModel[] = [];
+  let cursor: string | null = null;
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const result = await call('model/list', { cursor, includeHidden: false }) as CodexModelListPage;
+    listed.push(...(result.data ?? []));
+    cursor = result.nextCursor ?? null;
+    if (!cursor) break;
+  }
+
+  const visible = listed.filter((model) => model.model && !model.hidden);
+  if (visible.length === 0) throw new Error('codex app-server listed no models');
+  return {
+    OPTIONS: visible.map(toModelOption),
+    DEFAULT: (visible.find((model) => model.isDefault) ?? visible[0]).model,
+  };
+}
+
+export function discoverCodexModels(timeoutMs: number): Promise<ProviderModelsDefinition> {
+  return withStdioRpcServer(bundledCodexAppServer(), listCodexModels, timeoutMs);
+}