pipcode 0.0.0-stage → 2.1.1

package/src/engine/vuln-facts.js

@@ -0,0 +1,37 @@
+// src/engine/vuln-facts.js — Bloc « Vulnérabilités connues » de l'audit : dépendances lues dans les fichiers du projet, interrogées sur OSV.dev. Honnête : version non épinglée = non vérifiable (dit), panne ou réglage = « non vérifiées »
+// (jamais « aucune faille »). Désactivable : PLUGCTO_NO_OSV=1. Seuls noms et versions sont envoyés.
+import { readDeps } from "./deps-parse.js";
+import { osvScan, SEVERITY } from "./osv.js";
+
+const HEAD = "--- Vulnérabilités connues (base publique OSV.dev) ---";
+const ORDER = ["critique", "élevée", "moyenne", "faible", "inconnue"];
+const SHOWN = 15;
+
+/** @param {string} root @param {string[]} files @param {typeof fetch} [f] @param {Record<string, string | undefined>} [env] @returns {Promise<string>} */
+export async function vulnFacts(root, files, f = fetch, env = process.env) {
+  if (env.PLUGCTO_NO_OSV === "1") return `${HEAD}\nNON VÉRIFIÉES : interrogation désactivée par réglage (PLUGCTO_NO_OSV=1).`;
+  const { deps, unsupported } = await readDeps(root, files);
+  const skipped = unsupported.length ? ` Gestionnaires non analysés : ${unsupported.join(", ")}.` : "";
+  if (deps.length === 0) return `${HEAD}\nAucune dépendance analysable trouvée.${skipped}`;
+  const priv = deps.filter((d) => d.priv).length;
+  const loose = deps.filter((d) => !d.priv && (!d.pinned || !d.version));
+  const looseTxt = loose.length ? ` ; ${loose.length} sans version épinglée, donc NON vérifiables (${loose.slice(0, 8).map((d) => d.name).join(", ")}${loose.length > 8 ? ", …" : ""})` : "";
+  try {
+    const r = await osvScan(deps, f);
+    const rows = r.hits.map((h) => {
+      const infos = h.ids.map((id) => r.info.get(id) ?? { id, cve: "", severity: "inconnue", fixed: "" });
+      const worst = ORDER.find((s) => infos.some((x) => x.severity === s)) ?? "inconnue";
+      const fixed = infos.map((x) => x.fixed).filter(Boolean).sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).pop();
+      return { worst, text: `${h.dep.name}@${h.dep.version} (${h.dep.ecosystem}) : ${h.ids.length} faille(s), la pire ${worst} — ${infos.slice(0, 3).map((x) => x.cve || x.id).join(", ")}${fixed ? ` ; corrigée à partir de ${fixed}` : ""}` };
+    }).sort((a, b) => ORDER.indexOf(a.worst) - ORDER.indexOf(b.worst));
+    const counts = ORDER.map((s) => `${s} ${rows.filter((x) => x.worst === s).length}`).join(", ");
+    const day = new Date().toISOString().slice(0, 10);
+    return [HEAD, `Interrogée le ${day} ; seuls les noms et versions des dépendances ont été envoyés.`,
+      `Dépendances analysées : ${r.scanned} (versions exactes)${looseTxt}${priv ? ` ; ${priv} privée(s) ou locale(s), jamais envoyée(s)` : ""}.${skipped}`,
+      rows.length ? `Dépendances vulnérables : ${rows.length} (${counts})` : r.scanned === 0 ? "Dépendances vulnérables : NON VÉRIFIÉES (aucune version exacte à interroger) ; n'écris jamais « aucune faille connue »." : "Dépendances vulnérables : aucune dans la base à cette date pour les versions analysées (cela ne prouve pas l'absence de faille inconnue).",
+      ...rows.slice(0, SHOWN).map((x) => `- ${x.text}`), ...(rows.length > SHOWN ? [`- … ${rows.length - SHOWN} autres`] : [])].join("\n");
+  } catch (e) {
+    return `${HEAD}\nNON VÉRIFIÉES : la base OSV.dev n'a pas pu être interrogée (${/** @type {Error} */ (e).message.slice(0, 80)}). Dépendances lues : ${deps.length}${looseTxt}. À contrôler avec l'outil du gestionnaire (npm audit, pip-audit…).${skipped}`;
+  }
+}
+// MODULE_COMPLETE

package/src/fs/atomic-text.js

@@ -0,0 +1,45 @@
+// src/fs/atomic-text.js — Écriture atomique d'un fichier TEXTE de config (tmp +
+// rename). Anti TOCTOU/symlink (tmp à entropie), rename atomique, durcissement
+// 0600 (H2). Socle commun des écritures JSON (atomic-write.js) et TOML (Codex).
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { restrictSecretPerms } from "./permissions.js";
+import { warnIfBlocked } from "./os-errors.js";
+
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+/** @typedef {{ restrict?: typeof restrictSecretPerms }} WriteTextOpts */
+
+// Nom de fichier temporaire à entropie (anti TOCTOU/symlink attack).
+/** @param {string} filePath @returns {string} */
+export function tmpNameFor(filePath) {
+  return `${filePath}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+}
+
+/** @param {string} filePath @param {string} data @param {WriteTextOpts} [opts] @returns {Promise<void>} */
+export async function writeTextAtomic(filePath, data, { restrict = restrictSecretPerms } = {}) {
+  const dir = path.dirname(filePath);
+  try { await fs.mkdir(dir, { recursive: true }); }
+  catch (err) { warnIfBlocked(`création du dossier ${dir}`, err); throw err; }
+  const tmp = tmpNameFor(filePath);
+  try {
+    await fs.writeFile(tmp, data, { encoding: "utf8", mode: 0o600 });
+    await fs.rename(tmp, filePath); // atomique (POSIX) ; Windows best-effort.
+  } catch {
+    // tmp/rename en échec (handle IDE ouvert, blocage antivirus) → fallback
+    // write-then-unlink (non atomique mais fonctionnel).
+    try {
+      await fs.writeFile(filePath, data, { encoding: "utf8", mode: 0o600 });
+      await fs.rm(tmp, { force: true });
+    } catch (err2) {
+      const e2 = /** @type {NodeErr} */ (err2);
+      warnIfBlocked(`écriture de ${filePath}`, err2);
+      try { await fs.rm(tmp, { force: true }); } catch { /* best-effort : nettoyage */ }
+      throw new Error(`Écriture impossible (${filePath}). Fermez l'IDE cible et relancez setup. Détail : ${e2.message}`);
+    }
+  }
+  // H2 : durcissement ACL best-effort (Windows icacls / POSIX chmod 0o600).
+  await restrict(filePath);
+}
+// MODULE_COMPLETE

package/src/fs/atomic-write.js

@@ -0,0 +1,21 @@
+// src/fs/atomic-write.js — Écriture atomique d'un fichier de config JSON : sérialise
+// puis délègue à writeTextAtomic (atomic-text.js). tmpNameFor est ré-exporté
+// (invariant de tests : signature publique inchangée).
+
+import { writeTextAtomic, tmpNameFor } from "./atomic-text.js";
+import { restrictSecretPerms } from "./permissions.js";
+
+export { tmpNameFor };
+
+/** @typedef {{ restrict?: typeof restrictSecretPerms }} WriteConfigOpts */
+
+/**
+ * @param {string} filePath
+ * @param {Record<string, unknown>} config
+ * @param {WriteConfigOpts} [opts]
+ * @returns {Promise<void>}
+ */
+export async function writeConfigAtomic(filePath, config, opts = {}) {
+  await writeTextAtomic(filePath, JSON.stringify(config, null, 2) + "\n", opts);
+}
+// MODULE_COMPLETE

package/src/fs/backup-once.js

@@ -0,0 +1,27 @@
+// src/fs/backup-once.js — Sauvegarde UNIQUE du fichier de config d'origine d'un
+// utilisateur avant la première modification par PipCode (`<fichier>.pipcode.bak`,
+// permissions restreintes). N'écrase jamais une sauvegarde existante (la toute
+// première reste l'état d'origine). Fichier absent → rien à sauvegarder. Si la
+// sauvegarde est impossible, l'erreur remonte : on ne modifie PAS sans filet.
+
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import { restrictSecretPerms } from "./permissions.js";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+/** @param {string} filePath @returns {Promise<"created" | "kept" | "none">} */
+export async function backupOnce(filePath) {
+  const bak = `${filePath}.pipcode.bak`;
+  try {
+    await fs.copyFile(filePath, bak, constants.COPYFILE_EXCL);
+  } catch (err) {
+    const code = /** @type {NodeErr} */ (err).code;
+    if (code === "ENOENT") return "none"; // première installation : rien à sauvegarder.
+    if (code === "EEXIST") return "kept"; // l'état d'origine est déjà sauvegardé.
+    throw new Error(`Sauvegarde de ${filePath} impossible (${/** @type {NodeErr} */ (err).message}) : fichier non modifié.`);
+  }
+  await restrictSecretPerms(bak);
+  return "created";
+}
+// MODULE_COMPLETE

package/src/fs/config-path.js

@@ -0,0 +1,39 @@
+// src/fs/config-path.js — Bornage des racines config sous le home utilisateur.
+// Les fichiers de config IDE contiennent les clés API en clair (0600). Un env
+// contrôlé (APPDATA / XDG_CONFIG_HOME) ne doit pas rediriger l'écriture hors du
+// profil. `underHome` vérifie qu'un chemin résolu reste sous `home` ; `boundRoot`
+// honore l'override env uniquement s'il est borné, sinon retombe sur le défaut.
+
+import path from "node:path";
+import { resolvePlugctoRoot } from "./home-root.js";
+
+// Racine de la config partagée (~/.pipcode/config.json) — résiliente : la racine
+// honore PLUGCTO_CONFIG_DIR, sinon le home sondé, sinon le repli tmpdir (Point #3).
+/** @param {string} [configDir] @returns {string} */
+export function sharedConfigPath(configDir = resolvePlugctoRoot()) {
+  return path.join(configDir, "config.json");
+}
+
+/** @param {string} p @param {string} home @returns {boolean} */
+export function underHome(p, home) {
+  if (!p || typeof p !== "string") return false;
+  try {
+    const rp = path.resolve(p);
+    const rh = path.resolve(home);
+    return rp === rh || rp.startsWith(rh + path.sep);
+  } catch {
+    return false;
+  }
+}
+
+/** @param {string | undefined} envVal @param {string} home @param {string} fallback @returns {string} */
+export function boundRoot(envVal, home, fallback) {
+  return (envVal && underHome(envVal, home)) ? envVal : fallback;
+}
+
+// Racines config par défaut (sous home). Partagées par la localisation IDE.
+/** @param {string} home @returns {string} */
+export const DEFAULT_XDG = (home) => path.join(home, ".config");
+/** @param {string} home @returns {string} */
+export const DEFAULT_APPDATA = (home) => path.join(home, "AppData", "Roaming");
+// MODULE_COMPLETE

package/src/fs/config-read.js

@@ -0,0 +1,23 @@
+// src/fs/config-read.js — Lecture best-effort de ~/.pipcode/config.json.
+// Retourne {} si absent/corrompu. Sert à PRÉVENIR l'écrasement d'une licence Pro
+// existante (U1) lors d'un relance de setup.
+
+import path from "node:path";
+import fs from "node:fs/promises";
+import { sharedConfigPath } from "./config-path.js";
+
+/** @typedef {{ installedAt?: string, clientId?: string, licenseKey?: string, email?: string, trialExpiredNotified?: boolean }} SharedConfig */
+
+// Lit la config partagée ; {} si absent, non-objet ou corrompu (parse échoue).
+/** @param {{ configDir?: string, readFile?: typeof fs.readFile }} [opts] @returns {Promise<SharedConfig>} */
+export async function readSharedConfig({ configDir, readFile = fs.readFile } = {}) {
+  const file = configDir ? path.join(configDir, "config.json") : sharedConfigPath();
+  try {
+    const cfg = /** @type {SharedConfig} */ (JSON.parse(await readFile(file, "utf8")));
+    if (typeof cfg !== "object" || Array.isArray(cfg) || cfg === null) return {};
+    return cfg;
+  } catch {
+    return {};
+  }
+}
+// MODULE_COMPLETE

package/src/fs/config-write.js

@@ -0,0 +1,60 @@
+// src/fs/config-write.js — Écriture atomique de ~/.pipcode/config.json : merge
+// idempotent, tmp + rename + ACL 0600, repli direct. Blocages OS → warning propre.
+
+import path from "node:path";
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { sharedConfigPath } from "./config-path.js";
+import { tmpNameFor } from "./atomic-write.js";
+import { restrictSecretPerms } from "./permissions.js";
+import { warnIfBlocked } from "./os-errors.js";
+
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+/** @typedef {{ installedAt?: string, clientId?: string, licenseKey?: string, email?: string, trialExpiredNotified?: boolean }} SharedConfig */
+/** @typedef {{ licenseKey?: string, email?: string }} WriteSharedConfigInput */
+
+// Fusionne la cfg existante avec licenseKey/email (préserve installedAt/clientId).
+/** @param {SharedConfig} cfg @param {WriteSharedConfigInput} input @returns {SharedConfig} */
+function mergeSharedCfg(cfg, { licenseKey, email }) {
+  if (!cfg.installedAt) cfg.installedAt = new Date().toISOString();
+  if (!cfg.clientId) cfg.clientId = crypto.randomUUID();
+  if (licenseKey !== undefined) cfg.licenseKey = String(licenseKey || "");
+  if (email !== undefined) cfg.email = String(email || "");
+  return cfg;
+}
+
+/**
+ * @param {WriteSharedConfigInput} input
+ * @param {{ configDir?: string, readFile?: typeof fs.readFile, writeFile?: typeof fs.writeFile, mkdir?: typeof fs.mkdir, rename?: typeof fs.rename, rm?: typeof fs.rm, restrict?: typeof restrictSecretPerms }} [opts]
+ * @returns {Promise<{ path: string, email: string, licenseKey: string }>}
+ */
+export async function writeSharedConfig(
+  { licenseKey, email },
+  { configDir, readFile = fs.readFile, writeFile = fs.writeFile, mkdir = fs.mkdir, rename = fs.rename, rm = fs.rm, restrict = restrictSecretPerms } = {},
+) {
+  const file = configDir ? path.join(configDir, "config.json") : sharedConfigPath();
+  const dir = path.dirname(file);
+  /** @type {SharedConfig} */ let cfg = {};
+  try { cfg = /** @type {SharedConfig} */ (JSON.parse(await readFile(file, "utf8"))); } catch { cfg = {}; }
+  if (typeof cfg !== "object" || Array.isArray(cfg) || cfg === null) cfg = {};
+  cfg = mergeSharedCfg(cfg, { licenseKey, email });
+  await mkdir(dir, { recursive: true });
+  const data = JSON.stringify(cfg, null, 2) + "\n";
+  const tmp = tmpNameFor(file);
+  try {
+    await writeFile(tmp, data, { encoding: "utf8", mode: 0o600 });
+    await rename(tmp, file);
+  } catch {
+    // tmp/rename en échec (handle IDE, blocage antivirus) → écriture directe en repli.
+    try { await writeFile(file, data, { encoding: "utf8", mode: 0o600 }); } catch (err2) {
+      const e2 = /** @type {NodeErr} */ (err2);
+      warnIfBlocked(`écriture de ${file}`, err2);
+      try { await rm(tmp, { force: true }); } catch { /* best-effort : nettoyage du tmp */ }
+      throw new Error(`Écriture config impossible (${file}). Détail : ${e2.message}`);
+    }
+    try { await rm(tmp, { force: true }); } catch { /* best-effort : nettoyage du tmp */ }
+  }
+  await restrict(file);
+  return { path: file, email: /** @type {string} */ (cfg.email), licenseKey: /** @type {string} */ (cfg.licenseKey) };
+}
+// MODULE_COMPLETE

package/src/fs/home-root.js

@@ -0,0 +1,55 @@
+// src/fs/home-root.js — Résilience de la racine ~/.pipcode (Point bloquant #3).
+// Ordre : override PLUGCTO_CONFIG_DIR (honoré tel quel) → home utilisateur
+// (USERPROFILE/AppData en repli Windows si homedir() est vide) → os.tmpdir() en
+// dernier recours si le profil est verrouillé en écriture (sonde réelle, pas de
+// croyance ACL) + avertissement propre sur stderr. La sonde ne crée JAMAIS de
+// dossier : un dry-run teardown reste non intrusif.
+
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** @typedef {{ probeDir?: (dir: string) => boolean, warn?: (msg: string) => void }} RootOpts */
+
+// Cache des sondes par répertoire (une seule sonde par dossier et par process).
+/** @type {Map<string, boolean>} */
+const probeCache = new Map();
+
+// Sonde réelle d'inscriptibilité : écrit puis supprime un fichier éphémère.
+/** @param {string} dir @returns {boolean} */
+function probeDir(dir) {
+  if (probeCache.has(dir)) return /** @type {boolean} */ (probeCache.get(dir));
+  let ok = false;
+  try {
+    const probe = path.join(dir, `.pc-probe-${process.pid}`);
+    fsSync.writeFileSync(probe, "");
+    fsSync.rmSync(probe, { force: true });
+    ok = true;
+  } catch { ok = false; }
+  probeCache.set(dir, ok);
+  return ok;
+}
+
+// Home candidat : homedir() puis USERPROFILE/AppData (Windows) puis tmpdir.
+/** @param {NodeJS.ProcessEnv} env @returns {string} */
+function candidateHome(env) {
+  return os.homedir()
+    || /** @type {string} */ (env.USERPROFILE)
+    || (env.APPDATA ? path.dirname(env.APPDATA) : os.tmpdir());
+}
+
+// Racine effective du dossier .pipcode (défaut de sharedConfigPath/teardown).
+/** @param {NodeJS.ProcessEnv} [env] @param {RootOpts} [opts] @returns {string} */
+export function resolvePlugctoRoot(env = process.env, opts = {}) {
+  if (env.PLUGCTO_CONFIG_DIR) return env.PLUGCTO_CONFIG_DIR;
+  const probe = opts.probeDir || probeDir;
+  const warn = opts.warn || console.error;
+  const home = candidateHome(env);
+  const primary = path.join(home, ".pipcode");
+  // Sonde : dans ~/.pipcode s'il existe, sinon dans home (aucune création).
+  if (probe(fsSync.existsSync(primary) ? primary : home)) return primary;
+  const fallback = path.join(os.tmpdir(), "plugcto");
+  warn(`[pipcode] Répertoire utilisateur non inscriptible (${primary}) — antivirus ou droits insuffisants. Repli gracieux sur ${fallback}.`);
+  return fallback;
+}
+// MODULE_COMPLETE

package/src/fs/load-config.js

@@ -0,0 +1,36 @@
+// src/fs/load-config.js — Lecture générique d'un fichier de config JSON.
+// Fichier absent → {} (premier lancement). Fichier vide → {}.
+// Fichier corrompu → jette une Error explicite (on n'écrase jamais silencieusement
+// une config existante qu'on n'arrive pas à lire). Utilisé par applySetup (IDE).
+
+import fs from "node:fs/promises";
+
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function loadConfig(filePath) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    if (e && e.code === "ENOENT") return {};
+    throw e;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  try {
+    const parsed = /** @type {Record<string, unknown>} */ (JSON.parse(trimmed));
+    return (parsed && typeof parsed === "object" && !Array.isArray(parsed)) ? parsed : {};
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    throw new Error(
+      `Configuration existante illisible (${filePath}) : JSON invalide. ` +
+      `Corrigez ou supprimez le fichier avant de relancer setup. Détail : ${e.message}`,
+    );
+  }
+}
+// MODULE_COMPLETE

package/src/fs/os-errors.js

@@ -0,0 +1,26 @@
+// src/fs/os-errors.js — Interception typée des blocages d'accès OS (Point #3) :
+// antivirus, droits restreints, verrou exclusif, FS en lecture seule. Source
+// unique du test isOsBlock et de l'avertissement stderr propre (sans stack).
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+// Codes signalant un blocage d'accès fichier (AV / droits / verrou / FS ro).
+export const OS_BLOCK_CODES = ["EACCES", "EPERM", "EBUSY", "EROFS"];
+
+// Vrai si l'erreur est un blocage d'accès OS typé (code explicite).
+/** @param {unknown} err @returns {boolean} */
+export function isOsBlock(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = /** @type {NodeErr} */ (err);
+  return typeof e.code === "string" && OS_BLOCK_CODES.includes(e.code);
+}
+
+// Avertissement propre sur stderr (jamais de stack brute) si et seulement si
+// l'erreur est un blocage OS. Les autres erreurs restent silencieuses ici.
+/** @param {string} label @param {unknown} err @param {(msg: string) => void} [warn] @returns {void} */
+export function warnIfBlocked(label, err, warn = console.error) {
+  const e = /** @type {NodeErr} */ (err);
+  if (!isOsBlock(err)) return;
+  warn(`[pipcode] ${label} : accès bloqué par l'OS (${e.code}) — antivirus ou droits insuffisants.`);
+}
+// MODULE_COMPLETE

package/src/fs/permissions.js

@@ -0,0 +1,48 @@
+// src/fs/permissions.js — Restriction des permissions d'un fichier secret (H2).
+// POSIX : chmod 0o600. Windows : `mode` de fs.writeFile ignoré → ACL via icacls
+// (héritage coupé, accès réservé à l'utilisateur courant, retrait des groupes).
+// Best-effort : un échec icacls ne fait pas échouer l'écriture.
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import { detectOS } from "../cli/detect-os.js";
+
+/** @typedef {{ stdout: string, stderr: string }} ExecResult */
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+/** @typedef {{ osName?: string, runTool?: (cmd: string, args: string[]) => Promise<ExecResult> }} RestrictOpts */
+/** @typedef {{ ok: boolean, method: string, error?: string }} RestrictResult */
+
+// Promisification de execFile (windowsHide pour éviter une console flash).
+/** @param {string} cmd @param {string[]} args @returns {Promise<ExecResult>} */
+export function execFileAsync(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { windowsHide: true }, (err, stdout, stderr) => {
+      if (err) reject(err);
+      else resolve({ stdout: stdout, stderr: stderr });
+    });
+  });
+}
+
+/**
+ * @param {string} filePath
+ * @param {RestrictOpts} [opts]
+ * @returns {Promise<RestrictResult>}
+ */
+export async function restrictSecretPerms(filePath, { osName = detectOS(), runTool = execFileAsync } = {}) {
+  if (osName !== "windows") {
+    try { await fs.chmod(filePath, 0o600); } catch { /* best-effort POSIX */ }
+    return { ok: true, method: "chmod" };
+  }
+  const user = (process.env.USERNAME || process.env.USER || "").trim();
+  const args = [filePath, "/inheritance:r"];
+  if (user) args.push("/grant:r", `${user}:F`);
+  args.push("/remove:g", "Everyone", "Users", "Authenticated Users");
+  try {
+    await runTool("icacls", args);
+    return { ok: true, method: "icacls" };
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    return { ok: false, method: "icacls", error: String(e && (e.message || e)) };
+  }
+}
+// MODULE_COMPLETE

package/src/mcp/boot-warmup.js

@@ -0,0 +1,9 @@
+// src/mcp/boot-warmup.js — Tâche de boot en arrière-plan du serveur MCP : init AST (lazy), fire-and-forget. L'init Tree-sitter WASM est async (~50-100ms) : lancée en arrière-plan
+// pour ne pas bloquer le handshake stdio ; tant qu'elle n'est pas prête, l'analyse retombe sur le repli regex (jamais de crash). Aucun appel à un modèle : le serveur n'a aucune clé d'IA.
+import { loadAstRuntime } from "../engine/ast-runtime.js";
+
+/** @returns {void} */
+export function startBootTasks() {
+  loadAstRuntime().catch((e) => console.error("[virtual-cto] init AST:", (e && e.message) || e));
+}
+// MODULE_COMPLETE

package/src/mcp/call-tool.js

@@ -0,0 +1,20 @@
+// src/mcp/call-tool.js — Handler tools/call : dispatch par nom d'outil (extrait
+// dans tool-dispatch.js, plafond de lignes) + notice de transition Trial → Lite
+// (une fois, flag persisté par maybeTrialExpiredNotice ; la notice va dans le
+// content JSON-RPC, jamais sur stdout — stdout guard).
+import { loadConfigCached } from "../core/config-cache.js";
+import { maybeTrialExpiredNotice } from "../core/tier.js";
+import { dispatchTool } from "./tool-dispatch.js";
+
+/** @param {McpToolRequest} request @returns {Promise<McpToolResponse>} */
+export async function handleCallTool(request) {
+  let _trialNotice = "";
+  try { _trialNotice = await maybeTrialExpiredNotice(await loadConfigCached()); }
+  catch { _trialNotice = ""; }
+  const _res = await dispatchTool(request);
+  if (_trialNotice && _res && Array.isArray(_res.content)) {
+    _res.content = [..._res.content, { type: "text", text: `\n\nℹ️ ${_trialNotice}` }];
+  }
+  return _res;
+}
+// MODULE_COMPLETE

package/src/mcp/client-info.js

@@ -0,0 +1,35 @@
+// src/mcp/client-info.js — Capture du clientInfo MCP (nom/version de l'agent
+// hôte : Claude Code, Cursor, Copilot…) + table de capacités multi-agent. État
+// module pur (aucune I/O, aucune dépendance SDK). Gap d'audit #1 : PipCode sait
+// désormais si l'agent de l'environnement peut déployer lui-même le multi-agent.
+
+/** @type {ClientInfo | null} */ let current = null;
+
+// Mémorise le client MCP (validation Zero Trust : objet + name non vide requis).
+/** @param {unknown} info @returns {void} */
+export function rememberClient(info) {
+  if (!info || typeof info !== "object") return;
+  const name = /** @type {{ name?: unknown }} */ (info).name;
+  if (typeof name !== "string" || !name.trim()) return;
+  const version = /** @type {{ version?: unknown }} */ (info).version;
+  current = { name: name.trim(), version: typeof version === "string" ? version : "" };
+}
+
+// Client courant (ou null si l'initialize n'a pas encore eu lieu).
+/** @returns {ClientInfo | null} */
+export function getClientInfo() { return current; }
+
+// L'agent hôte sait-il déployer nativement plusieurs sous-agents ?
+/** @param {string} name @returns {boolean} */
+export function hostCanMultiAgent(name) {
+  return /claude|cursor|cline|windsurf|copilot|trae|kilo|codex/i.test(String(name || "").toLowerCase());
+}
+
+// Indice de délégation pour les rapports (vide si hôte inconnu ou non capable).
+/** @returns {string} */
+export function multiAgentHint() {
+  const c = current;
+  if (!c || !hostCanMultiAgent(c.name)) return "";
+  return `Délégation : votre agent hôte (${c.name}) sait déployer plusieurs sous-agents — déléguez-lui la correction multi-agents plutôt que de relancer PipCode en boucle.`;
+}
+// MODULE_COMPLETE

package/src/mcp/engine-rules.js

@@ -0,0 +1,16 @@
+// src/mcp/engine-rules.js — Gate « règles métier » des outils MCP : charge (ou rafraîchit) les règles
+// signées du serveur PipCode avant tout traitement. Échec = réponse d'erreur honnête, jamais de repli sur
+// des règles embarquées (il n'y en a plus). Même forme que les autres gates (ok / content).
+
+import { ensureRules } from "../rules/rules-load.js";
+
+/** @param {PlugConfig} cfg @returns {Promise<{ ok: true } | { ok: false, content: { type: "text", text: string }[] }>} */
+export async function gateEngineRules(cfg) {
+  try {
+    await ensureRules(cfg);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, content: [{ type: "text", text: `🛑 ${/** @type {Error} */ (e).message}` }] };
+  }
+}
+// MODULE_COMPLETE

package/src/mcp/handle-dlp.js

@@ -0,0 +1,37 @@
+// src/mcp/handle-dlp.js — Handler de l'outil dlp_scan : scan anti-fuite de
+// doctrine (sortie IA / contenu fichier) contre les empreintes du <CTO_VAULT>.
+import { DLP_BLOCK_TEXT, scanForLeak, hasVaultFingerprints } from "../core/dlp.js";
+
+/** @param {Record<string, unknown> | undefined} args @returns {McpToolResponse} */
+export function handleDlpScan(args) {
+  const candidate = args && typeof args.text === "string" ? args.text : "";
+  if (!candidate.trim()) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: "Paramètre `text` manquant ou vide pour dlp_scan." }],
+    };
+  }
+  if (!hasVaultFingerprints()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "ℹ️ [DLP] Aucun <CTO_VAULT> chargé en session — rien à protéger. Appelez d'abord un outil enforce_* pour charger la doctrine.",
+        },
+      ],
+    };
+  }
+  if (scanForLeak(candidate)) {
+    // Blocage DLP : extraction de doctrine détectée.
+    return {
+      isError: true,
+      content: [{ type: "text", text: DLP_BLOCK_TEXT }],
+    };
+  }
+  return {
+    content: [
+      { type: "text", text: "✅ [DLP] Aucune fuite de doctrine détectée. Sortie autorisée." },
+    ],
+  };
+}
+// MODULE_COMPLETE

package/src/mcp/handle-licence.js

@@ -0,0 +1,46 @@
+// src/mcp/handle-licence.js — Outil plugcto_licence (commande /licence) : voir l'état de la licence, ouvrir la page d'achat, enregistrer une clé. Disponible en Lite (aucun gate).
+// La clé est contrôlée par le serveur de licence AVANT d'être enregistrée ; une clé refusée n'efface jamais une licence existante ; la clé n'apparaît jamais en clair dans une réponse.
+import { loadConfig } from "../core/config.js";
+import { saveConfig } from "../core/config-base.js";
+import { invalidateConfigCache } from "../core/config-cache.js";
+import { resolveSessionResilient } from "../core/session-resilient.js";
+import { requestSession, purgeSessionCache } from "../core/session-net.js";
+import { PRO_UPGRADE_URL } from "../core/constants.js";
+import { openBrowser } from "../net/auth-endpoints.js";
+import { KEY_RE } from "../cli/setup-args.js";
+import { maskKey, statusText, refusedText } from "./licence-text.js";
+
+/** @param {string} text @param {boolean} [isError] @returns {McpToolResponse} */
+const reply = (text, isError = false) => ({ isError, content: [{ type: "text", text }] });
+/** @typedef {{ open?: (url: string) => void, request?: typeof requestSession, resolve?: typeof resolveSessionResilient }} LicenceDeps */
+
+/** @param {string} key @param {LicenceDeps} deps @returns {Promise<McpToolResponse>} */
+async function register(key, deps) {
+  if (!KEY_RE.test(key)) return reply(refusedText("Clé mal formée (8 à 128 caractères : lettres, chiffres, tirets)."), true);
+  const previous = process.env.PLUGCTO_LICENSE_KEY;
+  process.env.PLUGCTO_LICENSE_KEY = key; // la vérification utilise cette clé (l'environnement prime sur la config)
+  const restore = () => { if (previous === undefined) delete process.env.PLUGCTO_LICENSE_KEY; else process.env.PLUGCTO_LICENSE_KEY = previous; };
+  const cfg = await loadConfig();
+  try { await (deps.request ?? requestSession)({ ...cfg, licenseKey: key }); }
+  catch (err) {
+    restore();
+    const e = /** @type {EnrichedError} */ (err);
+    return reply(refusedText(e.status === 402 || e.status === 403 || e.status === 404 ? "Clé refusée par le serveur de licence." : "Serveur de licence injoignable."), true);
+  }
+  cfg.licenseKey = key; await saveConfig(cfg); invalidateConfigCache(); purgeSessionCache();
+  const kept = (await loadConfig()).licenseKey === key;
+  const stale = previous && previous !== key ? "\nVotre outil garde l'ancienne clé dans sa configuration : relancez « npx pipcode setup --key <votre clé> » pour la mettre à jour." : "";
+  return reply(`✅ Licence enregistrée (clé ${maskKey(key)}).${kept ? "" : " ⚠️ Enregistrement sur le disque impossible : valable pour cette session seulement."}${stale}`);
+}
+
+/** @param {Record<string, unknown> | undefined} args @param {LicenceDeps} [deps] @returns {Promise<McpToolResponse>} */
+export async function handleLicence(args, deps = {}) {
+  const action = args && typeof args.action === "string" ? args.action : "status";
+  if (action === "buy") { (deps.open ?? openBrowser)(PRO_UPGRADE_URL); return reply(`🌐 Page d'achat ouverte dans votre navigateur : ${PRO_UPGRADE_URL}\nUne fois la clé reçue par e-mail, collez-la ici : elle sera enregistrée.`); }
+  if (action === "register") return register(args && typeof args.key === "string" ? args.key.trim() : "", deps);
+  if (action !== "status") return reply("Action inconnue : utilisez « status », « buy » ou « register ».", true);
+  const cfg = await loadConfig();
+  const r = await (deps.resolve ?? resolveSessionResilient)(cfg);
+  return reply(statusText(r.tier, process.env.PLUGCTO_LICENSE_KEY || cfg.licenseKey || "", cfg.installedAt));
+}
+// MODULE_COMPLETE

package/src/mcp/handle-list.js

@@ -0,0 +1,15 @@
+// src/mcp/handle-list.js — Handler tools/list : catalogue statique (hors-ligne,
+// instantané) + DLP. Délégation à buildToolsList ; erreur tracée stderr puis
+// relancée (le SDK transforme l'exception en erreur JSON-RPC propre).
+import { buildToolsList } from "./tools-list.js";
+
+/** @returns {Promise<{ tools: McpToolDef[] }>} */
+export async function handleListTools() {
+  try {
+    return buildToolsList();
+  } catch (err) {
+    console.error("[virtual-cto] Erreur ListTools :", err);
+    throw err;
+  }
+}
+// MODULE_COMPLETE