create-byan-agent 2.59.3 → 2.60.1

package/install/bin/create-byan-agent-v2.js

@@ -15,6 +15,8 @@ const { getDomainQuestions, buildPhase2Prompt } = require('../lib/domain-questio
 const { generateProjectAgentsDoc } = require('../lib/project-agents-generator');
 const { launchPhase2Chat, generateDefaultConfig } = require('../lib/phase2-chat');
 const { setupByanWebIntegration, validateByanWebReachability } = require('../lib/byan-web-integration');
+const { resolveTargetUser } = require('../lib/target-user');
+const { commandExists: resolveCommandExists } = require('../lib/resolve-binary');
 const { setupLeantimeIntegration, validateLeantimeReachability } = require('../lib/byan-leantime-integration');
 const { setupRtkIntegration, shouldOfferRtk } = require('../lib/rtk-integration');
 const { setupClaudeNative } = require('../lib/claude-native-setup');
@@ -180,51 +182,29 @@ async function copyV2Runtime(templateDir, projectRoot, spinner) {
 // Detect installed platforms (Yanstaller logic)
 // Detects SYSTEM binaries, not project folders (.codex, .github/agents are created by yanstaller)
 async function detectPlatforms() {
+  // Meme resolveur que le moteur d'installation (install/lib/resolve-binary.js),
+  // et meme utilisateur cible que lui. Cette fonction lancait `which codex` puis
+  // `which claude` : `which` est absent de Windows, et sous elevation le PATH
+  // interroge est celui de root, donc les deux binaires passaient pour absents.
+  // Le repli sur ~/.config n'aidait pas non plus, os.homedir() rendant /root.
+  const cible = resolveTargetUser({ cwd: process.cwd() });
+  const home = cible.home || os.homedir();
   const platforms = {
-    codex: false,
-    claude: false
+    codex: resolveCommandExists('codex', { home }),
+    claude: resolveCommandExists('claude', { home }),
   };
 
-  // Codex detection (binary + config, NOT project .codex/ folder)
-  try {
-    const result = execSync('which codex 2>/dev/null', { encoding: 'utf8' }).trim();
-    if (result) {
-      platforms.codex = true;
-    }
-  } catch (e) {
-    // Fallback: check config directory
-    const codexPaths = [
-      path.join(os.homedir(), '.config', 'codex'),
-      path.join(os.homedir(), '.codex')
-    ];
-    for (const p of codexPaths) {
-      if (fs.existsSync(p)) {
-        platforms.codex = true;
-        break;
-      }
-    }
-  }
-  
-  // Claude Code detection (binary + config)
-  try {
-    const result = execSync('which claude 2>/dev/null', { encoding: 'utf8' }).trim();
-    if (result) {
-      platforms.claude = true;
-    }
-  } catch (e) {
-    // Fallback: check config directory
-    const claudePaths = [
-      path.join(os.homedir(), '.config', 'claude'),
-      path.join(os.homedir(), '.claude')
-    ];
-    for (const p of claudePaths) {
-      if (fs.existsSync(p)) {
-        platforms.claude = true;
-        break;
-      }
-    }
-  }
-  
+  // Repli par le dossier de configuration, dans le home de la CIBLE : un CLI
+  // installe puis retire laisse sa configuration, et un binaire hors de tout
+  // emplacement connu reste detectable par elle.
+  const parConfig = (nom) => [
+    path.join(home, '.config', nom),
+    path.join(home, `.${nom}`),
+  ].some((p) => fs.existsSync(p));
+
+  if (!platforms.codex) platforms.codex = parConfig('codex');
+  if (!platforms.claude) platforms.claude = parConfig('claude');
+
   return platforms;
 }
 
@@ -1395,7 +1375,7 @@ async function install(options = {}) {
     console.log(chalk.cyan('byan_web integration (optional — service payant)'));
     let byanWebResult = { configured: false };
     try {
-      byanWebResult = await setupByanWebIntegration(projectRoot);
+      byanWebResult = await setupByanWebIntegration(projectRoot, { homeDir: resolveTargetUser({ cwd: projectRoot }).home || undefined });
     } catch (error) {
       console.log(chalk.yellow(`  [WARN] byan_web setup skipped: ${error.message}`));
     }
@@ -1914,11 +1894,35 @@ async function installAuto(options) {
   // Default is notice-only ; --sync-skills opts in to an unattended sync.
   const ask = skillsSyncConsent(options);
 
+  // --ask ouvre les questions au lieu du parcours automatique. On reutilise le
+  // demandeur existant (setupByanWebIntegration -> promptForToken), qui pose
+  // l'URL et le token puis ecrit .env, .mcp.json et ~/.byan/credentials.json.
+  // En ecrire un second ferait diverger l'experience entre create-byan-agent et
+  // update-byan-agent, exactement ce que l'extraction de token-prompt evitait.
+  let apiUrlChoisie = options.apiUrl || null;
+  if (options.ask) {
+    console.log(chalk.cyan('\n  Mode question : configuration de l API byan_web\n'));
+    try {
+      // Le home de la CIBLE, pas celui du processus : sous elevation, ce flux
+      // ecrivait le jeton de l'utilisateur dans /root/.byan.
+      const cible = resolveTargetUser({ cwd: projectRoot });
+      const r = await setupByanWebIntegration(projectRoot, { homeDir: cible.home || undefined });
+      if (r && r.configured && r.apiUrl) apiUrlChoisie = r.apiUrl;
+    } catch (error) {
+      console.log(chalk.yellow(`  [WARN] configuration byan_web ignoree : ${error.message}`));
+    }
+  }
+
   try {
     const result = await engine.runInstall({
       projectRoot,
       projectName: options.name || undefined,
       rtk: options.rtk !== false,
+      apiUrl: apiUrlChoisie,
+      // commander pose options.chown a false quand --no-chown est donne.
+      chown: options.chown !== false,
+      owner: options.owner || null,
+      group: options.group || null,
     }, {
       onStep: ({ index, total, label }) => {
         if (spinner) spinner.succeed();
@@ -1932,15 +1936,56 @@ async function installAuto(options) {
     console.log('');
     console.log(chalk.green.bold(`  Installation terminee — verification ${result.verify.passed}/${result.verify.total}`));
 
+    // Ce qui n'a PAS tourne se dit a voix haute. Avant, une etape ecartee
+    // disparaissait du plan et le compteur affichait une reussite sur un
+    // perimetre reduit sans le signaler (mesure du 2026-08-11).
+    for (const s of result.skipped || []) {
+      console.log(chalk.yellow(`  Etape sautee : ${s.id} — ${s.reason}`));
+    }
+    for (const c of (result.verify.skipped || [])) {
+      console.log(chalk.gray(`  Controle saute : ${c.name} — ${c.reason}`));
+    }
+    // Qui a ete pris pour cible, et ce qui a ete repris. Sans cette ligne,
+    // "Claude Code introuvable" reste une affirmation que personne ne peut
+    // verifier, et une reprise de droits reste invisible.
+    if (result.targetUser && result.targetUser.source !== 'self') {
+      const t = result.targetUser;
+      console.log(chalk.gray(`  Utilisateur cible : ${t.name || t.uid} (${t.source}), home ${t.home}`));
+    }
+    if (result.ownership) {
+      const o = result.ownership;
+      const g = o.group ? `, groupe ${o.group.name} : ${o.group.outcome}` : '';
+      // On affiche l'issue D'ENSEMBLE : le projet, le home et le groupe peuvent
+      // diverger, et n'annoncer que le projet taisait un echec sur ~/.byan.
+      const issue = o.overall || o.outcome;
+      const teinte = issue === 'failed' ? chalk.yellow : chalk.gray;
+      console.log(teinte(`  Droits : ${issue}${o.changed ? ` — ${o.changed} entree(s) reprises` : ''}${g}`));
+      if (o.homeSkipped) console.log(chalk.gray(`    ${o.homeSkipped}`));
+      for (const p of o.homeFailed || []) console.log(chalk.yellow(`    echec sur ${p}`));
+    }
+
     // End-of-install launch (F5): start Claude Code, with the byan-channel
     // when this CLI version supports it. --no-launch or a non-interactive
     // terminal prints the command instead of running it.
     if (result.launch) {
-      if (options.launch !== false && isTTY) {
+      // SOUS ELEVATION, ON N'OUVRE PAS CLAUDE — ON DONNE LA COMMANDE.
+      //
+      // Lancer claude ici le ferait tourner en root : tout ce qu'il ecrirait
+      // ensuite dans le projet reviendrait a root, et defairait la reprise des
+      // droits acquise a l'etape precedente. Le mode non interactif imprime deja
+      // la commande ; on emprunte le meme chemin plutot que d'inventer une
+      // descente de privilege pour un shell interactif.
+      const sousElevation = Boolean(result.targetUser && result.targetUser.elevated);
+      if (options.launch !== false && isTTY && !sousElevation) {
         console.log(chalk.cyan(`  Lancement de Claude Code : ${result.launch.command}\n`));
         const { spawnSync } = require('child_process');
         spawnSync(result.launch.command, { stdio: 'inherit', shell: true });
       } else {
+        if (sousElevation) {
+          const qui = result.targetUser.name || result.targetUser.uid;
+          console.log(chalk.yellow(`  Installation lancee sous elevation : Claude Code n'est pas demarre ici.`));
+          console.log(chalk.gray(`  Reprends la main en tant que ${qui}, puis dans le projet :`));
+        }
         console.log(chalk.gray(`  Pour lancer Claude Code : ${result.launch.command}`));
       }
     } else {
@@ -2013,6 +2058,11 @@ program
   .option('--no-launch', 'Ne pas lancer Claude Code en fin d installation (mode --cli)')
   .option('--no-rtk', 'Ne pas installer rtk automatiquement (mode --cli)')
   .option('--sync-skills', 'Mode --cli : synchroniser sans demander les copies globales ~/.claude/skills divergentes')
+  .option('--ask', 'Mode --cli : poser les questions (URL de l API byan_web, token) au lieu du parcours automatique')
+  .option('--api-url <url>', 'URL de l API byan_web (defaut : le host de production ; BYAN_API_URL de l environnement le remplace)')
+  .option('--no-chown', 'Ne pas reprendre le proprietaire des fichiers poses (installation deliberee en root)')
+  .option('--owner <user>', 'Forcer l utilisateur cible (nom ou uid) au lieu de le deduire de l elevation')
+  .option('--group <name>', 'Groupe partage pose sur le projet (setgid) : un usermod -aG suffit ensuite a donner l acces')
   .option('--legacy', 'Interview complete d origine (l ancien parcours a questions)')
   .action(async (options) => {
     const mode = chooseInstallMode(options);

package/install/lib/api-defaults.js

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * L'URL de l'API byan_web — une seule source, pour toute l'installation.
+ *
+ * D'OU VIENT CE FICHIER. Trois endroits posaient `http://localhost:3737` en
+ * dur : codex-native-setup.js, platforms/claude-code.js et le demandeur
+ * interactif token-prompt.js. Un projet installe sur une machine qui n'heberge
+ * pas byan_web recevait donc une configuration pointant sur son propre port
+ * 3737, ou rien n'ecoute. Le serveur MCP demarrait et ne joignait jamais l'API.
+ *
+ * LE HOST DE PRODUCTION, MESURE le 2026-08-11 :
+ *   curl https://byan-api.stark.a3n.fr/api/health
+ *     -> 200, application/json, {"status":"ok","version":"1.0.0"}
+ *   curl https://byan.stark.a3n.fr/api/health
+ *     -> 302 vers auth.acadenice.com, text/html
+ * Le second est l'interface web derriere une authentification SSO, pas l'API.
+ * C'est le piege deja ecrit dans .claude/rules/byan-api.md, et le meme que
+ * celui rencontre cote Leantime (un POST qui revient en page HTML de connexion
+ * au lieu d'un corps JSON). Prendre le host de l'interface pour celui de l'API
+ * produit une panne difficile a lire, parce que la reponse ressemble a une
+ * reponse.
+ */
+
+const path = require('path');
+
+// Le host mesure repondant en JSON. Changer cette constante change le defaut
+// de toute l'installation, terminal et assistant web compris.
+const PROD_API_URL = 'https://byan-api.stark.a3n.fr';
+
+// Conserve pour qui developpe byan_web en local et pose BYAN_API_URL lui-meme.
+const LOCAL_API_URL = 'http://localhost:3737';
+
+/**
+ * Retire le suffixe /api et la barre oblique finale.
+ *
+ * Les endpoints portent deja /api : une base qui le contient produit
+ * /api/api/projects. La verification de derive de install-core signale
+ * d'ailleurs ce cas (verify.js, "BYAN_API_URL has an /api suffix"), preuve que
+ * la faute a deja ete commise.
+ */
+function normalizeApiUrl(url) {
+  if (typeof url !== 'string') return '';
+  const propre = url.trim().replace(/\/+$/, '');
+  if (!propre) return '';
+  return propre.replace(/\/api$/i, '');
+}
+
+function isHttpUrl(url) {
+  return typeof url === 'string' && /^https?:\/\/\S+$/.test(url.trim());
+}
+
+/**
+ * L'URL retenue, et d'ou elle vient. L'ordre est le contrat :
+ *
+ *   1. 'explicit'    — ce que l'appelant a passe (--api-url, une reponse a une
+ *                      question). L'intention exprimee maintenant gagne.
+ *   2. 'env'         — BYAN_API_URL dans l'environnement. Le geste d'un
+ *                      administrateur ou d'une chaine d'integration continue.
+ *   3. 'credentials' — la valeur memorisee dans ~/.byan/credentials.json lors
+ *                      d'une installation precedente. Ne pas la relire ferait
+ *                      re-saisir a chaque projet ce qui a deja ete donne.
+ *   4. 'default'     — le host de production.
+ *
+ * `readCredentials` est injecte pour que ce module reste testable sans toucher
+ * au home de la machine.
+ */
+function resolveApiUrl({
+  explicit = null,
+  env = process.env,
+  homeDir = null,
+  readCredentials = null,
+} = {}) {
+  if (isHttpUrl(explicit)) return { url: normalizeApiUrl(explicit), source: 'explicit' };
+  if (env && isHttpUrl(env.BYAN_API_URL)) return { url: normalizeApiUrl(env.BYAN_API_URL), source: 'env' };
+
+  const lire = readCredentials || defaultReadCredentials;
+  try {
+    const memorise = lire({ homeDir });
+    if (memorise && isHttpUrl(memorise.BYAN_API_URL)) {
+      return { url: normalizeApiUrl(memorise.BYAN_API_URL), source: 'credentials' };
+    }
+  } catch {
+    // Un fichier de configuration absent ou abime ne doit pas arreter une
+    // installation : on descend simplement a l'echelon suivant.
+  }
+
+  return { url: PROD_API_URL, source: 'default' };
+}
+
+// Chargement paresseux : home-credentials tire fs-extra, et api-defaults est
+// requis par des modules qui n'ont pas besoin de cette chaine.
+function defaultReadCredentials({ homeDir } = {}) {
+  // eslint-disable-next-line global-require
+  const homeCreds = require(path.join(__dirname, 'home-credentials.js'));
+  return homeCreds.readCredentials(homeDir ? { homeDir } : {});
+}
+
+/** Raccourci pour les appelants qui ne veulent que la chaine. */
+function apiUrl(options = {}) {
+  return resolveApiUrl(options).url;
+}
+
+module.exports = {
+  PROD_API_URL,
+  LOCAL_API_URL,
+  normalizeApiUrl,
+  isHttpUrl,
+  resolveApiUrl,
+  apiUrl,
+};

package/install/lib/byan-web-integration.js

@@ -45,7 +45,7 @@ async function setupByanWebIntegration(projectRoot, options = {}) {
   // Soft-purge Google keys from ~/.byan/credentials.json — ALWAYS, meme si
   // l'utilisateur decline byan_web : les cles Google ne sont plus utilisees
   // par BYAN quel que soit le choix (proxy server-side).
-  const purgeResult = purgeGoogleKeys();
+  const purgeResult = purgeGoogleKeys(options.homeDir ? { homeDir: options.homeDir } : {});
   if (purgeResult.purged.length > 0) {
     const backupMsg = purgeResult.backupPath ? ` (backup : ${purgeResult.backupPath})` : '';
     console.log(chalk.gray(`  Cles Google retirees de ~/.byan/credentials.json${backupMsg}`));
@@ -71,7 +71,14 @@ async function setupByanWebIntegration(projectRoot, options = {}) {
   // boot (env -> ~/.byan/credentials.json -> localhost). This is what makes the
   // MCP portable across shells/OSes and Claude Code AND Codex, instead of
   // relying on .mcp.json ${} expansion or settings.local.json env injection.
-  const credsResult = await sharedWriteCredentials({ BYAN_API_URL: stripApiSuffix(inputs.apiUrl), BYAN_API_TOKEN: inputs.token });
+  // Le home est celui de la CIBLE quand l'appelant le connait. Sous elevation,
+  // os.homedir() rend /root : ce flux interactif y ecrivait le jeton de
+  // l'utilisateur, alors que le chemin non interactif (install-engine) passait
+  // deja le bon home. Les deux ecrivent maintenant au meme endroit.
+  const credsResult = await sharedWriteCredentials(
+    { BYAN_API_URL: stripApiSuffix(inputs.apiUrl), BYAN_API_TOKEN: inputs.token },
+    options.homeDir ? { homedir: options.homeDir } : {}
+  );
 
 
   if (!options.quiet) {

package/install/lib/codex-native-setup.js

@@ -18,27 +18,47 @@ const fs = require('fs-extra');
 const path = require('path');
 const os = require('os');
 const chalk = require('chalk');
+const apiDefaults = require('./api-defaults');
 
 const SERVER_NAME = 'byan';
 
-function getCodexConfigPath() {
-  return path.join(os.homedir(), '.codex', 'config.toml');
+// Le home est un PARAMETRE, pas une constante lue sur le processus.
+//
+// Motif mesure le 2026-08-11 : sous elevation de privilege, os.homedir() rend
+// /root. Ces trois fonctions ecrivaient donc dans /root/.codex au lieu du home
+// de l'utilisateur qui a lance la commande. home-credentials.js et
+// global-skills-sync.js acceptaient deja un homeDir ; ce module etait le seul
+// a ne pas offrir de porte d'entree, ce qui rendait la correction inapplicable.
+function safeHome() {
+  try {
+    return os.homedir();
+  } catch {
+    return '';
+  }
+}
+
+function getCodexConfigPath(homeDir) {
+  return path.join(homeDir || safeHome(), '.codex', 'config.toml');
 }
 
-function getCodexSkillsDir() {
-  return path.join(os.homedir(), '.codex', 'skills');
+function getCodexSkillsDir(homeDir) {
+  return path.join(homeDir || safeHome(), '.codex', 'skills');
 }
 
-async function detectCodex() {
-  return fs.pathExists(path.join(os.homedir(), '.codex'));
+async function detectCodex(homeDir) {
+  return fs.pathExists(path.join(homeDir || safeHome(), '.codex'));
 }
 
 // TOML literal-string escape: single quotes don't interpret backslashes,
 // so paths and tokens land verbatim. We just refuse values containing "'".
-function tomlLiteral(value) {
+function tomlLiteral(value, label) {
   const s = String(value);
   if (s.includes("'")) {
-    throw new Error(`Cannot encode value with single quote in TOML literal: ${s}`);
+    // LA VALEUR REFUSEE NE VOYAGE PAS DANS LE MESSAGE. Elle peut etre un jeton
+    // d'API : le message d'erreur remonte dans le detail de l'etape, journalise
+    // par install-engine et rediffuse au navigateur par l'assistant web. On
+    // nomme le champ, pas son contenu.
+    throw new Error(`valeur non encodable en litteral TOML (apostrophe interdite) : champ ${label || 'inconnu'}`);
   }
   return `'${s}'`;
 }
@@ -74,20 +94,20 @@ function buildByanBlock({ serverPath, apiUrl, apiToken, startupTimeoutSec = 15 }
   const lines = [
     '',
     '[mcp_servers.byan]',
-    `command = ${tomlLiteral('node')}`,
-    `args = [${tomlLiteral(serverPath)}]`,
+    `command = ${tomlLiteral('node', 'command')}`,
+    `args = [${tomlLiteral(serverPath, 'serverPath')}]`,
     `startup_timeout_sec = ${Number.isFinite(startupTimeoutSec) ? startupTimeoutSec : 15}`,
     '',
     '[mcp_servers.byan.env]',
-    `BYAN_API_URL = ${tomlLiteral(apiUrl)}`,
-    `BYAN_API_TOKEN = ${tomlLiteral(apiToken)}`,
+    `BYAN_API_URL = ${tomlLiteral(apiUrl, 'BYAN_API_URL')}`,
+    `BYAN_API_TOKEN = ${tomlLiteral(apiToken, 'BYAN_API_TOKEN')}`,
     '',
   ];
   return lines.join('\n');
 }
 
 async function patchCodexConfig(projectRoot, options = {}) {
-  const configPath = getCodexConfigPath();
+  const configPath = getCodexConfigPath(options.homeDir);
   const serverPath = path.join(
     projectRoot,
     '_byan',
@@ -103,10 +123,11 @@ async function patchCodexConfig(projectRoot, options = {}) {
     existing = await fs.readFile(configPath, 'utf8');
   }
 
-  const apiUrl =
-    options.apiUrl ||
-    process.env.BYAN_API_URL ||
-    'http://localhost:3737';
+  // Une seule source pour l'URL de l'API (install/lib/api-defaults.js). Le
+  // defaut valait localhost:3737 : un projet installe sur une machine qui
+  // n'heberge pas byan_web recevait une configuration pointant sur un port ou
+  // rien n'ecoute.
+  const apiUrl = apiDefaults.apiUrl({ explicit: options.apiUrl, homeDir: options.homeDir });
   const apiToken =
     options.apiToken !== undefined
       ? options.apiToken
@@ -123,7 +144,21 @@ async function patchCodexConfig(projectRoot, options = {}) {
   const merged =
     (stripped.trimEnd().length > 0 ? stripped.trimEnd() + '\n' : '') + block;
 
-  await fs.writeFile(configPath, merged, 'utf8');
+  // CE FICHIER PORTE UN JETON D'API : IL SE FERME.
+  //
+  // fs.writeFile n'applique le mode qu'a la CREATION ; sur une reecriture, le
+  // fichier garde ses droits d'origine. D'ou le chmod qui suit, et le 0700 sur
+  // le dossier. Meme sequence que packages/platform-config/lib/credentials.js
+  // pour ~/.byan/credentials.json. Sans ca, config.toml sortait en 644 : lisible
+  // par tout compte de la machine.
+  await fs.writeFile(configPath, merged, { encoding: 'utf8', mode: 0o600 });
+  try {
+    await fs.chmod(configPath, 0o600);
+    await fs.chmod(path.dirname(configPath), 0o700);
+  } catch (_e) {
+    // Un systeme de fichiers sans droits POSIX (Windows, exFAT) ne sait pas
+    // faire ca. L'ecriture, elle, a eu lieu : on ne la defait pas pour autant.
+  }
   return { path: configPath, hadExisting: existing.length > 0, tokenSet: apiToken.length > 0 };
 }
 
@@ -172,7 +207,7 @@ function defaultSkillSourceDirs(projectRoot, options = {}) {
 }
 
 async function installCodexNativeSkills(projectRoot, options = {}) {
-  const destDir = options.destDir || getCodexSkillsDir();
+  const destDir = options.destDir || getCodexSkillsDir(options.homeDir);
   const sourceDirs = options.sourceDirs || defaultSkillSourceDirs(projectRoot, options);
   const overwrite = options.overwrite !== false;
 
@@ -205,7 +240,7 @@ async function installCodexNativeSkills(projectRoot, options = {}) {
 async function setupCodexNative(projectRoot, options = {}) {
   const log = options.quiet ? () => {} : (...a) => console.log(...a);
 
-  const present = await detectCodex();
+  const present = await detectCodex(options.homeDir);
   if (!present && !options.force) {
     log(chalk.gray('  · Codex CLI not detected (~/.codex absent), skipping'));
     return { skipped: true, reason: 'codex-not-detected' };