@piecemaker-legal/piecemaker 2.0.9 → 2.0.10

package/server/modules/providers/list/mistral/mistral-vibe-models.ts

@@ -0,0 +1,43 @@
+import type { ProviderModelOption } from '@/shared/types.js';
+
+type VibeModelPreset = {
+  name: string;
+  provider: string;
+  alias: string;
+  display_name: string;
+  adjustableReasoning: boolean;
+};
+
+export const VIBE_MODEL_PRESETS: readonly VibeModelPreset[] = [
+  { name: 'mistral-vibe-cli-latest', provider: 'mistral', alias: 'mistral-medium-3.5', display_name: 'Mistral Medium 3.5', adjustableReasoning: true },
+  { name: 'zai-glm-5-3', provider: 'mistral', alias: 'glm-5.3', display_name: 'Z.ai GLM 5.3', adjustableReasoning: false },
+  { name: 'zai-glm-5-2', provider: 'mistral', alias: 'glm-5.2', display_name: 'Z.ai GLM 5.2', adjustableReasoning: false },
+];
+
+export const VIBE_REASONING_EFFORT: NonNullable<ProviderModelOption['effort']> = {
+  default: 'high',
+  values: [
+    { value: 'none', description: 'Minimal thinking, no reasoning trace.' },
+    { value: 'high', description: 'Full reasoning before answering.' },
+  ],
+};
+
+const VIBE_THINKING_BY_EFFORT: Record<string, string> = { none: 'low', high: 'high' };
+
+export function vibeModelOption(alias: string, label: string, description?: string): ProviderModelOption {
+  const preset = VIBE_MODEL_PRESETS.find((candidate) => candidate.alias === alias);
+  return {
+    value: alias,
+    label,
+    ...(description ? { description } : {}),
+    ...(preset?.adjustableReasoning ? { effort: VIBE_REASONING_EFFORT } : {}),
+  };
+}
+
+export function buildVibeModelsEnvironment(selectedAlias?: string, effort?: string): string {
+  const thinking = effort ? VIBE_THINKING_BY_EFFORT[effort] : undefined;
+  return JSON.stringify(Object.fromEntries(VIBE_MODEL_PRESETS.map(({ adjustableReasoning, ...model }) => [
+    model.alias,
+    adjustableReasoning && thinking && model.alias === selectedAlias ? { ...model, thinking } : model,
+  ])));
+}

package/server/modules/providers/tests/mistral-vibe-models.test.ts

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { MISTRAL_PREDEFINED_MODELS } from '@/modules/providers/list/mistral/mistral-models.provider.js';
+import { buildVibeModelsEnvironment } from '@/modules/providers/list/mistral/mistral-vibe-models.js';
+
+test('Vibe receives the GLM models alongside Mistral Medium without overriding thinking by default', () => {
+  const models = JSON.parse(buildVibeModelsEnvironment());
+  assert.deepEqual(Object.keys(models), ['mistral-medium-3.5', 'glm-5.3', 'glm-5.2']);
+  assert.deepEqual(models['glm-5.3'], { name: 'zai-glm-5-3', provider: 'mistral', alias: 'glm-5.3', display_name: 'Z.ai GLM 5.3' });
+  assert.equal(models['mistral-medium-3.5'].thinking, undefined);
+});
+
+test('the selected effort becomes Vibe thinking only on models with adjustable reasoning', () => {
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'none'))['mistral-medium-3.5'].thinking, 'low');
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'high'))['mistral-medium-3.5'].thinking, 'high');
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('glm-5.3', 'high'))['glm-5.3'].thinking, undefined);
+  assert.equal(JSON.parse(buildVibeModelsEnvironment('mistral-medium-3.5', 'bogus'))['mistral-medium-3.5'].thinking, undefined);
+});
+
+test('the curated Mistral catalog lists GLM 5.3 and 5.2 and offers effort on Medium 3.5 only', () => {
+  const byValue = Object.fromEntries(MISTRAL_PREDEFINED_MODELS.OPTIONS.map((option) => [option.value, option]));
+  assert.deepEqual(Object.keys(byValue), ['mistral-medium-3.5', 'glm-5.3', 'glm-5.2', 'local']);
+  assert.deepEqual(byValue['mistral-medium-3.5'].effort?.values.map((value) => value.value), ['none', 'high']);
+  assert.equal(byValue['glm-5.3'].effort, undefined);
+  assert.equal(MISTRAL_PREDEFINED_MODELS.DEFAULT, 'mistral-medium-3.5');
+});

package/server/piecemaker/anonymizer/client-config.cjs

@@ -1,119 +1,119 @@
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
 
-function atomicWrite(file, content, mode = 0o600) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
+const LEGACY_PROXY_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',
+];
+
+function readObject(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeObject(file, value) {
   const temporary = `${file}.piecemaker-${process.pid}-${Date.now()}`;
-  fs.writeFileSync(temporary, content, { encoding: 'utf8', mode });
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
   fs.renameSync(temporary, file);
 }
 
-const PROXY_ENV = {
-  HTTPS_PROXY: (proxyUrl) => proxyUrl,
-  HTTP_PROXY: (proxyUrl) => proxyUrl,
-  ALL_PROXY: (proxyUrl) => proxyUrl,
-  NO_PROXY: () => 'localhost,127.0.0.1,::1',
-  NODE_USE_ENV_PROXY: () => '1',
-  NODE_EXTRA_CA_CERTS: (_proxyUrl, caFile) => caFile,
-  SSL_CERT_FILE: (_proxyUrl, caFile, trustBundle) => trustBundle || caFile,
-  CODEX_CA_CERTIFICATE: (_proxyUrl, caFile) => caFile,
-  REQUESTS_CA_BUNDLE: (_proxyUrl, caFile, trustBundle) => trustBundle || caFile,
-};
-
-function isLoopbackProxy(value) {
+function isLoopback(value) {
   try {
-    const url = new URL(String(value || ''));
-    return ['127.0.0.1', 'localhost'].includes(url.hostname);
+    return ['127.0.0.1', 'localhost'].includes(new URL(String(value || '')).hostname);
   } catch {
     return false;
   }
 }
 
-function configureClaudeCodeProxy({ proxyUrl, caFile, trustBundle, userHome = os.homedir() } = {}) {
-  const settingsFile = path.join(userHome, '.claude', 'settings.json');
-  let settings = {};
-  try {
-    if (fs.existsSync(settingsFile)) {
-      const parsed = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
-      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('objet JSON attendu');
-      settings = parsed;
-    }
-  } catch {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'settings-invalid' };
-  }
+function isProxyGuard(hook) {
+  return [hook?.command, hook?.commandWindows].some((command) => typeof command === 'string' && command.includes('proxy-guard.mjs'));
+}
 
-  if (settings.env !== undefined
-    && (!settings.env || typeof settings.env !== 'object' || Array.isArray(settings.env))) {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'env-invalid' };
-  }
-  if (!settings.env) settings.env = {};
-  const existingProxy = settings.env.HTTPS_PROXY;
-  if (existingProxy && existingProxy !== proxyUrl && !isLoopbackProxy(existingProxy)) {
-    return { configured: false, changed: false, conflict: true, file: settingsFile, reason: 'proxy-conflict' };
-  }
+function withoutProxyGuard(groups) {
+  if (!Array.isArray(groups)) return groups;
+  return groups
+    .map((group) => (Array.isArray(group?.hooks) ? { ...group, hooks: group.hooks.filter((hook) => !isProxyGuard(hook)) } : group))
+    .filter((group) => !Array.isArray(group?.hooks) || group.hooks.length);
+}
 
+function cleanClaudeSettings(file) {
+  const settings = readObject(file);
+  if (!settings) return false;
   let changed = false;
-  for (const [key, produce] of Object.entries(PROXY_ENV)) {
-    const value = produce(proxyUrl, caFile, trustBundle);
-    if (!value) continue;
-    if (settings.env[key] !== value) {
-      settings.env[key] = value;
-      changed = true;
-    }
+  if (settings.env && isLoopback(settings.env.HTTPS_PROXY)) {
+    for (const key of LEGACY_PROXY_KEYS) delete settings.env[key];
+    if (!Object.keys(settings.env).length) delete settings.env;
+    changed = true;
   }
-  if (!changed) return { configured: true, changed: false, conflict: false, file: settingsFile };
-  atomicWrite(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
-  return { configured: true, changed: true, conflict: false, file: settingsFile };
-}
-
-function bypassClaudeCodeProxy({ userHome = os.homedir() } = {}) {
-  const settingsFile = path.join(userHome, '.claude', 'settings.json');
-  if (!fs.existsSync(settingsFile)) {
-    return { bypassed: true, changed: false, conflict: false, file: settingsFile };
+  const current = settings.hooks?.SessionStart;
+  const sessionStart = withoutProxyGuard(current);
+  if (Array.isArray(current) && JSON.stringify(sessionStart) !== JSON.stringify(current)) {
+    if (sessionStart.length) settings.hooks.SessionStart = sessionStart;
+    else delete settings.hooks.SessionStart;
+    changed = true;
   }
+  if (changed) writeObject(file, settings);
+  return changed;
+}
 
-  let settings;
-  try {
-    settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
-    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) throw new Error('objet JSON attendu');
-  } catch {
-    return { bypassed: false, changed: false, conflict: true, file: settingsFile, reason: 'settings-invalid' };
-  }
+function cleanCodexHooks(file) {
+  const document = readObject(file);
+  const current = document?.hooks?.SessionStart;
+  const sessionStart = withoutProxyGuard(current);
+  if (!Array.isArray(current) || JSON.stringify(sessionStart) === JSON.stringify(current)) return false;
+  if (sessionStart.length) document.hooks.SessionStart = sessionStart;
+  else delete document.hooks.SessionStart;
+  writeObject(file, document);
+  return true;
+}
 
-  const env = settings.env;
-  if (!env || typeof env !== 'object' || Array.isArray(env)) {
-    if (env === undefined) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
-    return { bypassed: false, changed: false, conflict: true, file: settingsFile, reason: 'env-invalid' };
-  }
-  if (!isLoopbackProxy(env.HTTPS_PROXY)) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
+const LEGACY_CONFIG_KEYS = [
+  'mikePiiPort',
+  'caseFolders',
+  'anonymization',
+  'litellmPort',
+  'litellmVenvPath',
+  'mxcPath',
+  'mxcEnabled',
+  'adminTheme',
+  'port',
+];
 
+function cleanPieceMakerConfig(homeDir) {
+  const file = path.join(homeDir, 'config.json');
+  const config = readObject(file);
   let changed = false;
-  if (isLoopbackProxy(env.HTTPS_PROXY)) {
-    for (const key of Object.keys(PROXY_ENV)) {
-      if (env[key] !== undefined) {
-        delete env[key];
-        changed = true;
-      }
-    }
+  const legacyKeys = config ? LEGACY_CONFIG_KEYS.filter((key) => key in config) : [];
+  if (legacyKeys.length) {
+    for (const key of legacyKeys) delete config[key];
+    writeObject(file, config);
+    changed = true;
   }
-  if (!changed) return { bypassed: true, changed: false, conflict: false, file: settingsFile };
-  if (Object.keys(env).length === 0) delete settings.env;
-  atomicWrite(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
-  return { bypassed: true, changed: true, conflict: false, file: settingsFile };
-}
-
-function configureCodexProxy() {
-  return { configured: true, changed: false, conflict: false, file: null };
+  const statuslineCache = path.join(homeDir, 'proxy-statusline.json');
+  if (fs.existsSync(statuslineCache)) {
+    fs.rmSync(statuslineCache, { force: true });
+    changed = true;
+  }
+  return changed;
 }
 
-function bypassCodexProxy() {
-  return { bypassed: true, changed: false, conflict: false, file: null };
+function removeLegacyProxyConfig({ userHome, homeDir = path.join(userHome, '.piecemaker') }) {
+  const cleaned = [];
+  const attempt = (name, run) => {
+    try {
+      if (run()) cleaned.push(name);
+    } catch {
+      return;
+    }
+  };
+  attempt('claude', () => cleanClaudeSettings(path.join(userHome, '.claude', 'settings.json')));
+  attempt('codex', () => cleanCodexHooks(path.join(process.env.CODEX_HOME || path.join(userHome, '.codex'), 'hooks.json')));
+  attempt('piecemaker', () => cleanPieceMakerConfig(homeDir));
+  return cleaned;
 }
 
-module.exports = {
-  configureClaudeCodeProxy,
-  bypassClaudeCodeProxy,
-  configureCodexProxy,
-  bypassCodexProxy,
-};
+module.exports = { removeLegacyProxyConfig };

package/server/piecemaker/anonymizer/hudsucker-fixture.cjs

@@ -1,6 +1,5 @@
 const { execFileSync, spawn } = require('node:child_process');
 const fs = require('node:fs');
-const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
 
@@ -25,17 +24,6 @@ function makeCertificateAuthority(directory) {
   return { cert, key };
 }
 
-function freePort() {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once('error', reject);
-    server.listen(0, '127.0.0.1', () => {
-      const { port } = server.address();
-      server.close((error) => (error ? reject(error) : resolve(port)));
-    });
-  });
-}
-
 function waitForOutput(child, needle, timeoutMs) {
   return new Promise((resolve, reject) => {
     let buffer = '';
@@ -71,21 +59,23 @@ async function startHudsuckerSession({
   const ca = makeCertificateAuthority(directory);
   const dictionary = createSqliteDictionaryLoader({ databasePath });
   const bridge = await startRewriterBridge({ dictionary, harness });
-  const port = await freePort();
   const upstreamMap = hosts.map((host) => `${host}=127.0.0.1:${upstreamPort}`).join(',');
   const child = spawn(binary, [
-    '--listen', `127.0.0.1:${port}`,
+    '--listen', '127.0.0.1:0',
     '--rewriter', `http://127.0.0.1:${bridge.port}`,
     '--ca-cert', ca.cert,
     '--ca-key', ca.key,
     '--hosts', hosts.join(','),
     '--upstream-map', upstreamMap,
   ], {
-    stdio: ['ignore', 'pipe', 'pipe'],
+    stdio: ['pipe', 'pipe', 'pipe'],
     env: { ...process.env, HTTPS_PROXY: '', HTTP_PROXY: '', ALL_PROXY: '', http_proxy: '', https_proxy: '' },
   });
+  let logs = '';
+  child.stderr.on('data', (chunk) => { logs += chunk; });
+  let port;
   try {
-    await waitForOutput(child, `listening 127.0.0.1:${port}`, 15000);
+    port = (await waitForOutput(child, 'listening 127.0.0.1:', 15000)).match(/listening 127\.0\.0\.1:(\d+)/)[1];
   } catch (error) {
     child.kill('SIGKILL');
     await bridge.close();
@@ -96,6 +86,9 @@ async function startHudsuckerSession({
     origin: `http://127.0.0.1:${port}`,
     caFile: ca.cert,
     stats: bridge.stats,
+    child,
+    bridge,
+    logs: () => logs,
     async close() {
       child.kill('SIGTERM');
       await new Promise((resolve) => child.once('exit', resolve));

package/server/piecemaker/anonymizer/hudsucker-proxy/Cargo.toml

@@ -10,5 +10,5 @@ http-body-util = "0.1"
 hudsucker = { version = "0.25", default-features = false, features = ["decoder", "http2", "rcgen-ca", "rustls-client"] }
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "stream"] }
 serde_json = "1"
-tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync"] }
+tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "sync"] }
 tokio-stream = "0.1"