create-byan-agent 2.59.2 → 2.60.0

package/install/lib/target-user.js

@@ -0,0 +1,373 @@
+'use strict';
+
+/**
+ * TARGET USER — qui est le destinataire reel de l'installation.
+ *
+ * POURQUOI ce module : sous elevation de privilege (sudo, doas, pkexec, su),
+ * le processus voit os.homedir() a /root et un PATH de root. L'installateur
+ * cherche ~/.claude dans /root, ne trouve rien, et annonce une reussite en
+ * ayant saute l'etape Claude. Le probleme mesure le 2026-08-11 : aucune
+ * occurrence de SUDO_USER, SUDO_UID, DOAS_USER, PKEXEC_UID ou geteuid dans
+ * install/. Ce module rend l'humain derriere l'elevation, ou nomme
+ * explicitement le cas ou il n'y en a pas.
+ *
+ * L'echelle de resolution, chaque echelon nomme dans le champ `source` :
+ *
+ *   sudo       SUDO_UID numerique       -> uid/gid/nom depuis l'environnement
+ *   doas       DOAS_USER                -> nom seul, uid resolu via /etc/passwd
+ *   pkexec     PKEXEC_UID numerique     -> uid seul, nom resolu via /etc/passwd
+ *   cwd-owner  processus root, dossier de travail a un humain (couvre su)
+ *   root       processus root, dossier de travail a root — resultat legitime
+ *              (conteneur, integration continue, installation dans /opt)
+ *   self       processus non-root, la cible est celui qui lance
+ *
+ * POURQUOI une fonction pure : elle lit l'environnement, /etc/passwd et un stat
+ * du dossier de travail au travers des dependances injectees. Aucune ecriture,
+ * aucun spawn, aucune lecture de la machine hote en test.
+ */
+
+const nodeFs = require('fs');
+const os = require('os');
+
+const PASSWD_PATH = '/etc/passwd';
+
+// Home conventionnel du compte root, par famille de systeme. POURQUOI a part :
+// root ne suit pas la convention /home/<nom> des comptes humains.
+const ROOT_HOME = { darwin: '/var/root', linux: '/root' };
+
+/**
+ * Lit un uid/gid transmis par l'environnement. Rend un nombre ou null.
+ * POURQUOI un test de forme et pas Number() seul : Number('abc') rend NaN, et
+ * un NaN propage dans un uid produit un chown ou une comparaison silencieusement
+ * fausse. Une valeur qui n'est pas une suite de chiffres fait descendre d'un
+ * echelon plutot que de produire un uid inexploitable.
+ */
+function numericOrNull(value) {
+  if (typeof value !== 'string' && typeof value !== 'number') return null;
+  const text = String(value).trim();
+  if (!/^[0-9]+$/.test(text)) return null;
+  const parsed = Number(text);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+
+/**
+ * Parse /etc/passwd (format nom:x:uid:gid:gecos:home:shell). POURQUOI cette
+ * source : Node n'expose pas de binding getpwnam, et /etc/passwd est la source
+ * portable Linux + macOS pour les comptes locaux. Une lecture impossible rend
+ * une liste vide — l'appelant descend alors sur le repli conventionnel.
+ */
+function readPasswdEntries(fs, passwdPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(passwdPath, 'utf8');
+  } catch (_e) {
+    return [];
+  }
+  if (typeof raw !== 'string') return [];
+
+  const entries = [];
+  const lines = raw.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.charAt(0) === '#') continue;
+    const fields = line.split(':');
+    if (fields.length < 6) continue;
+    const uid = numericOrNull(fields[2]);
+    if (uid === null) continue;
+    entries.push({
+      name: fields[0],
+      uid,
+      gid: numericOrNull(fields[3]),
+      home: nonEmptyString(fields[5]),
+    });
+  }
+  return entries;
+}
+
+function findEntry(entries, { name, uid }) {
+  for (let i = 0; i < entries.length; i++) {
+    if (name !== null && name !== undefined && entries[i].name === name) return entries[i];
+  }
+  for (let i = 0; i < entries.length; i++) {
+    if (uid !== null && uid !== undefined && entries[i].uid === uid) return entries[i];
+  }
+  return null;
+}
+
+function conventionalHome(name, uid, platform) {
+  if (uid === 0 || name === 'root') {
+    return ROOT_HOME[platform] || ROOT_HOME.linux;
+  }
+  if (name === null || name === undefined) return null;
+  return platform === 'darwin' ? '/Users/' + name : '/home/' + name;
+}
+
+/**
+ * Coeur de la resolution nom + home. Rend une forme unique, dans tous les cas :
+ * { name, uid, gid, home, homeSource }.
+ *
+ * homeSource nomme la source retenue, pour que le rapport final puisse la citer :
+ *   'passwd'     — ligne trouvee dans /etc/passwd
+ *   'convention' — /home/<nom>, /Users/<nom>, ou le home de root
+ *   'env'        — variable d'environnement (USERPROFILE) ou identite du
+ *                  processus courant (os.userInfo)
+ *   'unknown'    — aucune des trois n'a pu conclure ; home vaut null. Ce n'est
+ *                  pas un repli, c'est l'absence honnete d'un resultat.
+ */
+function resolveHomeDetails({ name, uid, fs, platform, env, passwdPath }) {
+  if (platform === 'win32') {
+    const winHome = nonEmptyString(env && env.USERPROFILE);
+    return {
+      name: name || nonEmptyString(env && env.USERNAME),
+      uid: null,
+      gid: null,
+      home: winHome,
+      homeSource: winHome ? 'env' : 'unknown',
+    };
+  }
+
+  const entries = readPasswdEntries(fs, passwdPath);
+  const entry = findEntry(entries, { name, uid });
+
+  if (entry && entry.home) {
+    return {
+      name: entry.name,
+      uid: uid === null || uid === undefined ? entry.uid : uid,
+      gid: entry.gid,
+      home: entry.home,
+      homeSource: 'passwd',
+    };
+  }
+
+  const resolvedName = name || (entry ? entry.name : null) || (uid === 0 ? 'root' : null);
+  const home = conventionalHome(resolvedName, uid === undefined ? null : uid, platform);
+  return {
+    name: resolvedName,
+    uid: uid === null || uid === undefined ? (entry ? entry.uid : null) : uid,
+    gid: entry ? entry.gid : null,
+    home,
+    homeSource: home ? 'convention' : 'unknown',
+  };
+}
+
+/**
+ * Morceau reutilisable : resoudre le home d'un compte donne par son nom ou son
+ * uid. Une suite de chiffres est lue comme un uid — sur le chemin d'elevation,
+ * les sources numeriques (SUDO_UID, PKEXEC_UID) sont les seules a porter un uid.
+ */
+function resolveHomeFor(nameOrUid, {
+  fs = nodeFs,
+  platform = process.platform,
+  env = process.env,
+  passwdPath = PASSWD_PATH,
+} = {}) {
+  let name = null;
+  let uid = null;
+
+  if (typeof nameOrUid === 'number') {
+    uid = Number.isFinite(nameOrUid) ? nameOrUid : null;
+  } else if (typeof nameOrUid === 'string') {
+    const asNumber = numericOrNull(nameOrUid);
+    if (asNumber === null) name = nonEmptyString(nameOrUid);
+    else uid = asNumber;
+  }
+
+  return resolveHomeDetails({ name, uid, fs, platform, env, passwdPath });
+}
+
+function safeUserInfo(userInfo) {
+  if (typeof userInfo !== 'function') return null;
+  try {
+    const info = userInfo();
+    return info && typeof info === 'object' ? info : null;
+  } catch (_e) {
+    // POURQUOI avaler : os.userInfo throw quand le compte du processus n'a pas
+    // d'entree passwd (conteneur avec un uid arbitraire). L'absence d'identite
+    // se traite comme un echelon qui ne conclut pas.
+    return null;
+  }
+}
+
+function ownerUidOf(fs, cwd) {
+  try {
+    const stat = fs.statSync(cwd);
+    return stat && typeof stat.uid === 'number' ? stat.uid : null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * resolveTargetUser — rend { uid, gid, name, home, homeSource, source, elevated }.
+ * Fonction pure : rien n'est ecrit, l'environnement fourni n'est pas modifie.
+ */
+function resolveTargetUser({
+  env = process.env,
+  platform = process.platform,
+  fs = nodeFs,
+  userInfo = os.userInfo,
+  cwd = process.cwd(),
+  geteuid = typeof process.geteuid === 'function' ? process.geteuid.bind(process) : null,
+  passwdPath = PASSWD_PATH,
+} = {}) {
+  const safeEnv = env || {};
+
+  // Windows n'a pas d'uid/gid, et une elevation UAC ne laisse aucune variable
+  // d'environnement exploitable — on ne l'invente pas.
+  if (platform === 'win32') {
+    const details = resolveHomeDetails({
+      name: nonEmptyString(safeEnv.USERNAME),
+      uid: null,
+      fs,
+      platform,
+      env: safeEnv,
+      passwdPath,
+    });
+    return {
+      uid: null,
+      gid: null,
+      name: details.name,
+      home: details.home,
+      homeSource: details.homeSource,
+      source: 'self',
+      elevated: false,
+    };
+  }
+
+  // L'ELEVATION EST UN FAIT, PAS UNE VARIABLE D'ENVIRONNEMENT.
+  //
+  // Les trois echelons ci-dessous lisaient SUDO_UID, DOAS_USER ou PKEXEC_UID et
+  // annoncaient elevated:true sans regarder l'uid effectif. Or ces variables
+  // survivent dans l'environnement d'un shell lance depuis une session elevee
+  // puis redescendue : le processus n'est plus root, mais il se declarait
+  // eleve. L'appelant lancait alors une reprise de droits qui ne pouvait que
+  // se faire refuser. On lit donc l'uid effectif AVANT de trancher.
+  const uidEffectif = typeof geteuid === 'function' ? geteuid() : null;
+  const estRoot = uidEffectif === 0;
+
+  const sudoUid = numericOrNull(safeEnv.SUDO_UID);
+  if (sudoUid !== null) {
+    const name = nonEmptyString(safeEnv.SUDO_USER);
+    const details = resolveHomeDetails({ name, uid: sudoUid, fs, platform, env: safeEnv, passwdPath });
+    const sudoGid = numericOrNull(safeEnv.SUDO_GID);
+    return {
+      uid: sudoUid,
+      gid: sudoGid !== null ? sudoGid : details.gid,
+      name: name || details.name,
+      home: details.home,
+      homeSource: details.homeSource,
+      source: 'sudo',
+      elevated: estRoot,
+    };
+  }
+
+  const doasUser = nonEmptyString(safeEnv.DOAS_USER);
+  if (doasUser !== null) {
+    // doas ne pose pas d'uid : le nom est la seule prise, l'uid vient de passwd.
+    const details = resolveHomeDetails({ name: doasUser, uid: null, fs, platform, env: safeEnv, passwdPath });
+    return {
+      uid: details.uid,
+      gid: details.gid,
+      name: doasUser,
+      home: details.home,
+      homeSource: details.homeSource,
+      source: 'doas',
+      elevated: estRoot,
+    };
+  }
+
+  const pkexecUid = numericOrNull(safeEnv.PKEXEC_UID);
+  if (pkexecUid !== null) {
+    const details = resolveHomeDetails({ name: null, uid: pkexecUid, fs, platform, env: safeEnv, passwdPath });
+    return {
+      uid: pkexecUid,
+      gid: details.gid,
+      name: details.name,
+      home: details.home,
+      homeSource: details.homeSource,
+      source: 'pkexec',
+      elevated: estRoot,
+    };
+  }
+
+  if (estRoot) {
+    const ownerUid = ownerUidOf(fs, cwd);
+
+    // POURQUOI ce repli : su ne laisse aucune variable derriere lui. Le
+    // proprietaire du dossier de travail est alors la meilleure trace de
+    // l'humain a qui appartient le projet.
+    if (ownerUid !== null && ownerUid !== 0) {
+      const details = resolveHomeDetails({ name: null, uid: ownerUid, fs, platform, env: safeEnv, passwdPath });
+      return {
+        uid: ownerUid,
+        gid: details.gid,
+        name: details.name,
+        home: details.home,
+        homeSource: details.homeSource,
+        source: 'cwd-owner',
+        elevated: true,
+      };
+    }
+
+    // Le dossier de travail appartient a root, ou son stat a echoue : la cible
+    // EST root. Resultat de premiere classe, distinguable par source === 'root'.
+    const rootDetails = resolveHomeDetails({ name: 'root', uid: 0, fs, platform, env: safeEnv, passwdPath });
+    return {
+      uid: 0,
+      gid: rootDetails.gid !== null ? rootDetails.gid : 0,
+      name: rootDetails.name || 'root',
+      home: rootDetails.home,
+      homeSource: rootDetails.homeSource,
+      source: 'root',
+      elevated: true,
+    };
+  }
+
+  const info = safeUserInfo(userInfo);
+  const selfUid = info && typeof info.uid === 'number' ? info.uid : uidEffectif;
+  const selfName = (info && nonEmptyString(info.username))
+    || nonEmptyString(safeEnv.USER)
+    || nonEmptyString(safeEnv.LOGNAME);
+  // $HOME PRIME SUR passwd QUAND ON N'EST PAS ELEVE.
+  //
+  // os.userInfo().homedir lit /etc/passwd. Sans elevation, l'environnement
+  // appartient a l'utilisateur lui-meme : s'il a deplace son HOME (compte de
+  // service, conteneur de developpement, home monte ailleurs), c'est $HOME qui
+  // dit la verite et passwd qui ment. Le resolveur de binaire applique deja
+  // cette regle dans safeHome ; les deux divergeaient. Sous elevation on ne
+  // touche pas a ca : $HOME y appartient a root, pas a la cible.
+  const selfHome = nonEmptyString(safeEnv.HOME) || (info && nonEmptyString(info.homedir));
+
+  if (selfHome) {
+    return {
+      uid: selfUid,
+      gid: info && typeof info.gid === 'number' ? info.gid : null,
+      name: selfName,
+      home: selfHome,
+      homeSource: 'env',
+      source: 'self',
+      elevated: false,
+    };
+  }
+
+  const details = resolveHomeDetails({ name: selfName, uid: selfUid, fs, platform, env: safeEnv, passwdPath });
+  return {
+    uid: selfUid !== null && selfUid !== undefined ? selfUid : details.uid,
+    gid: info && typeof info.gid === 'number' ? info.gid : details.gid,
+    name: selfName || details.name,
+    home: details.home,
+    homeSource: details.homeSource,
+    source: 'self',
+    elevated: false,
+  };
+}
+
+module.exports = {
+  resolveTargetUser,
+  resolveHomeFor,
+  PASSWD_PATH,
+};

package/install/lib/yanstaller/agent-launcher.js

@@ -9,6 +9,7 @@
 
 const { execSync, spawn } = require('child_process');
 const logger = require('../utils/logger');
+const { commandExists } = require('../resolve-binary');
 
 /**
  * @typedef {Object} LaunchOptions
@@ -64,14 +65,11 @@ const LAUNCH_CONFIGS = {
       
       return args;
     },
-    checkAvailable: () => {
-      try {
-        execSync('which claude', { stdio: 'ignore' });
-        return true;
-      } catch {
-        return false;
-      }
-    }
+    // Meme resolveur que le moteur d'installation. Avant, cette sonde lancait
+    // `which claude` : absente de Windows, et fausse des que le processus
+    // n'herite pas du PATH de l'utilisateur. Le commentaire en tete de
+    // webui-detection.test.js documente la panne que cette divergence a produite.
+    checkAvailable: () => commandExists('claude'),
   },
   
   'codex': {
@@ -98,14 +96,7 @@ const LAUNCH_CONFIGS = {
       
       return args;
     },
-    checkAvailable: () => {
-      try {
-        execSync('which codex', { stdio: 'ignore' });
-        return true;
-      } catch {
-        return false;
-      }
-    }
+    checkAvailable: () => commandExists('codex'),
   }
 };
 

package/install/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.51.0",
+  "version": "2.60.0",
   "description": "BYAN - Intelligent AI agent installer with multi-platform native support (Claude Code, Codex/OpenCode)",
   "bin": {
     "create-byan-agent": "bin/create-byan-agent-v2.js"

package/install/packages/platform-config/lib/token-prompt.js

@@ -8,7 +8,13 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 
-const DEFAULT_API_URL = 'http://localhost:3737';
+// La valeur proposee par defaut vient de la source unique (install/lib/
+// api-defaults.js). Elle valait localhost:3737 : la question proposait donc a
+// l'utilisateur de pointer sur sa propre machine, ou byan_web ne tourne pas.
+// Chargement par chemin relatif, comme le reste des liens entre install/lib et
+// ce paquet — la dependance file: avait produit le defaut d'empaquetage
+// corrige en 2.59.3.
+const { PROD_API_URL: DEFAULT_API_URL } = require('../../../lib/api-defaults');
 const ENV_KEYS = ['BYAN_API_TOKEN', 'BYAN_API_URL'];
 const LEANTIME_ENV_KEYS = [
   'LEANTIME_API_URL',

package/install/src/webui/api.js

@@ -216,11 +216,24 @@ const routes = {
         ask: null,
       });
 
+      // La face web recoit la MEME structure que le terminal, etapes sautees
+      // comprises. Sans elles, l'assistant continuerait d'annoncer une reussite
+      // sur un perimetre reduit en silence.
+      const sautees = result.skipped || [];
+      const messageOk = sautees.length
+        ? `Installation BYAN terminee — ${sautees.length} etape(s) sautee(s)`
+        : 'Installation BYAN terminee';
       server.broadcastComplete(result.ok, {
-        message: result.ok ? 'Installation BYAN terminee' : 'Installation terminee avec des etapes en echec',
+        message: result.ok ? messageOk : 'Installation terminee avec des etapes en echec',
         projectRoot,
         verify: result.verify,
         steps: result.steps,
+        skipped: sautees,
+        // La page de fin affiche ces deux-la : sans eux, elle ne pouvait pas
+        // dire au nom de qui l'installation a tourne ni si les droits ont pu
+        // etre repris.
+        targetUser: result.targetUser,
+        ownership: result.ownership,
         launch: result.launch,
       });
     } catch (err) {

package/install/src/webui/public/app.js

@@ -449,6 +449,45 @@ class ByanApp {
       if (s.projectRoot) html += `<p><strong>Projet :</strong> <code>${this.escapeHtml(s.projectRoot)}</code></p>`;
       if (s.mode) html += `<p><strong>Mode :</strong> ${this.escapeHtml(s.mode)}</p>`;
       if (s.platforms && s.platforms.length) html += `<p><strong>Plateformes :</strong> ${s.platforms.map(p => this.escapeHtml(p)).join(', ')}</p>`;
+
+      // CE QUI N'A PAS TOURNE SE DIT ICI AUSSI.
+      //
+      // Le moteur diffuse `skipped`, `verify.skipped` et `ownership` depuis la
+      // correction du rapport honnete, mais cette page n'en affichait rien :
+      // l'assistant web continuait d'annoncer une reussite pleine sur un
+      // perimetre reduit, exactement le defaut corrige cote terminal.
+      if (s.verify && typeof s.verify.passed === 'number') {
+        html += `<p><strong>Verification :</strong> ${s.verify.passed}/${s.verify.total} controles`;
+        if (s.verify.skipped && s.verify.skipped.length) {
+          html += ` — ${s.verify.skipped.length} saute(s) sur ${s.verify.intendedTotal || '?'}`;
+        }
+        html += '</p>';
+      }
+      if (s.skipped && s.skipped.length) {
+        html += '<p><strong>Etapes sautees :</strong></p><ul>';
+        for (const e of s.skipped) {
+          html += `<li><code>${this.escapeHtml(e.id)}</code> — ${this.escapeHtml(e.reason || 'sans raison donnee')}</li>`;
+        }
+        html += '</ul>';
+      }
+      if (s.targetUser && s.targetUser.elevated) {
+        const qui = s.targetUser.name || s.targetUser.uid;
+        html += `<p><strong>Utilisateur cible :</strong> ${this.escapeHtml(String(qui))} (${this.escapeHtml(s.targetUser.source || 'inconnu')})</p>`;
+      }
+      if (s.ownership) {
+        const issue = s.ownership.overall || s.ownership.outcome;
+        const couleur = issue === 'failed' ? 'var(--error)' : 'inherit';
+        html += `<p style="color:${couleur}"><strong>Droits :</strong> ${this.escapeHtml(String(issue))}`;
+        if (s.ownership.changed) html += ` — ${s.ownership.changed} entree(s) reprises`;
+        html += '</p>';
+        for (const p of s.ownership.homeFailed || []) {
+          html += `<p style="color:var(--error)">Echec de reprise sur <code>${this.escapeHtml(p)}</code></p>`;
+        }
+        if (s.ownership.homeSkipped) {
+          html += `<p style="color:var(--text-muted)">${this.escapeHtml(s.ownership.homeSkipped)}</p>`;
+        }
+      }
+
       html += '<p style="margin-top:1rem;color:var(--text-muted);">Tu peux fermer cette fenetre.</p>';
       summary.innerHTML = html;
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.59.2",
+  "version": "2.60.0",
   "description": "BYAN v2.8 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher + native Claude Code integration (hooks, skills, MCP server). Multi-platform (Claude Code, Codex). Merise Agile + TDD + 71 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {
@@ -79,7 +79,6 @@
     "@anthropic-ai/claude-code": "^2.1.114",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.9.0",
-    "byan-platform-config": "file:./install/packages/platform-config",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",

package/update-byan-agent/lib/migrate-mcp-config.js

@@ -16,7 +16,7 @@ const {
   mcpConfig: { readMcpConfig, ensureMcpConfig, TOKEN_PLACEHOLDER },
   envConfig:  { readEnvToken, updateDotenv },
   urlUtils:   { stripApiSuffix },
-} = require('byan-platform-config');
+} = require('../../install/packages/platform-config');
 
 /**
  * @param {string} projectRoot   — absolute path to the project root

package/update-byan-agent/package.json

@@ -26,7 +26,6 @@
   "author": "Yan",
   "license": "MIT",
   "dependencies": {
-    "byan-platform-config": "file:../install/packages/platform-config",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "diff": "^5.1.0",