oft-agt 0.0.0-stage → 0.5.1

package/cli.mjs

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+import { localStatus, startBackground, stopBackground, managedDaemon, readLogs, removeLocalInstance, ensureLocalLauncher } from './runtime/lifecycle.mjs';
+import { completeCredentialRotation, rotateCredential } from './runtime/agent-auth.mjs';
+import { authorizeDevice } from './runtime/device-login.mjs';
+import { generateKeyPairSync, privateDecrypt, constants, createDecipheriv } from 'node:crypto';
+import { readFile, writeFile, mkdir, rename, access, symlink, open, unlink, cp } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import WebSocket from 'ws';
+import { writeBot, compile } from './compiler.mjs';
+import { acceptSecret } from './secret.mjs';
+import { createUsageCollector } from './usage.mjs';
+import { instanceDirectory, resolveInstance, listInstances, rememberInstance } from './instance.mjs';
+import { AGENT_VERSION } from './version.mjs';
+import { installUpdate } from './update.mjs';
+import { supervise } from './supervisor.mjs';
+
+const baseHome = process.env.OFTONE_AGENT_HOME || path.join(homedir(), '.oftone-agent');
+let home = baseHome, configPath, secretPath, keyPath;
+function useHome(directory) { home = directory; configPath = path.join(home, 'agent.json'); secretPath = path.join(home, 'discord-secret.json'); keyPath = path.join(home, 'private.pem'); }
+useHome(baseHome);
+const require = createRequire(import.meta.url);
+let child;
+let active;
+let usage;
+let usageReady = true;
+function watchUsage(process) { process.on('message', message => { try { usage?.record(message); } catch { console.error('Mesure statistique ignorée.'); } }); return process; }
+async function exists(p) { try { await access(p); return true; } catch { return false; } }
+async function save(p, data) { await writeFile(p + '.tmp', typeof data === 'string' ? data : JSON.stringify(data), { mode: 0o600 }); await rename(p + '.tmp', p); }
+function decrypt(envelope, privateKey) {
+  const key = privateDecrypt({ key: privateKey, oaepHash: 'sha256', padding: constants.RSA_PKCS1_OAEP_PADDING }, Buffer.from(envelope.key, 'base64'));
+  const bytes = Buffer.from(envelope.ciphertext, 'base64');
+  const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(envelope.iv, 'base64'));
+  decipher.setAuthTag(bytes.subarray(-16));
+  return JSON.parse(Buffer.concat([decipher.update(bytes.subarray(0, -16)), decipher.final()]).toString('utf8'));
+}
+function run(executable, args, options) {
+  return new Promise((resolve, reject) => { const process = spawn(executable, args, { ...options, windowsHide: true, shell: false }); process.on('error', reject); process.on('exit', code => code === 0 ? resolve() : reject(new Error('PROCESS_FAILED'))); });
+}
+async function credentials(config) {
+  const secret = decrypt(JSON.parse(await readFile(secretPath, 'utf8')), await readFile(keyPath, 'utf8'));
+  if (secret.agentId !== config.agentId || !/^\d{17,20}$/.test(secret.applicationId) || typeof secret.token !== 'string') throw new Error('SECRET_INVALID');
+  return secret;
+}
+async function stopBot() {
+  const current = child;
+  if (!current || current.exitCode !== null || current.signalCode) return;
+  await new Promise(resolve => { const timer = setTimeout(() => current.kill('SIGKILL'), 5000); current.once('exit', () => { clearTimeout(timer); resolve(); }); current.kill('SIGTERM'); });
+}
+async function restartBot(config) {
+  if (!await exists(path.join(home, 'active.json'))) throw new Error('NO_DEPLOYMENT');
+  const release = JSON.parse(await readFile(path.join(home, 'active.json'), 'utf8'));
+  if (!/^[a-f0-9-]{36}$/.test(release.id)) throw new Error('INVALID_RELEASE');
+  const secret = await credentials(config);
+  await stopBot();
+  child = watchUsage(spawn(process.execPath, ['bot.mjs'], { cwd: path.join(home, 'releases', release.id), env: { ...Object.fromEntries(['PATH', 'HOME', 'USERPROFILE', 'SystemRoot', 'WINDIR', 'TEMP', 'TMP'].filter(key => process.env[key]).map(key => [key, process.env[key]])), DISCORD_TOKEN: secret.token, DISCORD_CLIENT_ID: secret.applicationId }, stdio: ['ignore', 'pipe', 'pipe', 'ipc'], windowsHide: true, shell: false }));
+  secret.token = '';
+  child.stderr.on('data', () => {});
+  await new Promise((resolve, reject) => { const timer = setTimeout(() => { child.kill(); reject(new Error('BOT_START_TIMEOUT')); }, 45000); const fail = () => { clearTimeout(timer); reject(new Error('BOT_START_FAILED')); }; child.once('error', fail); child.once('exit', fail); child.stdout.on('data', bytes => { if (bytes.toString().includes('Bot connecté :')) { clearTimeout(timer); child.off('error', fail); child.off('exit', fail); resolve(); } }); });
+  active = release.id;
+}
+async function deploy(config, message, notify) {
+  if (!/^[a-f0-9-]{36}$/.test(message.id)) throw new Error('DEPLOYMENT_INVALID');
+  compile(message.snapshot); // Never execute a plan or JavaScript supplied by the remote service.
+  notify('received');
+  const target = path.join(home, 'releases', message.id);
+  const state = await exists(path.join(home, 'active.json')) ? JSON.parse(await readFile(path.join(home, 'active.json'), 'utf8')) : null;
+  if (state?.id === message.id && child && child.exitCode === null && !child.signalCode) { notify('running'); return; }
+  notify('installing');
+  if (!await exists(target)) {
+    await writeBot(message.snapshot, target);
+    // Reuse the trusted agent package's dependencies; deployments never run npm or shell scripts.
+    const modules = path.resolve(path.dirname(require.resolve('discord.js')), '../..');
+    await symlink(modules, path.join(target, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
+  }
+  const secret = await credentials(config);
+  const env = { ...Object.fromEntries(['PATH', 'HOME', 'USERPROFILE', 'SystemRoot', 'WINDIR', 'TEMP', 'TMP', 'LANG', 'TZ'].filter(key => process.env[key]).map(key => [key, process.env[key]])), DISCORD_TOKEN: secret.token, DISCORD_CLIENT_ID: secret.applicationId };
+  // Remove credentials unrelated to running the Discord bot.
+  for (const key of Object.keys(env)) if (/OFTONE|AGENT_RELAY|CLOUDFLARE|SESSION_SECRET/.test(key)) delete env[key];
+  await run(process.execPath, ['bot.mjs', '--deploy'], { cwd: target, env, stdio: 'ignore' });
+  const previous = child;
+  const previousId = active;
+  if (previous && previous.exitCode === null && !previous.signalCode) {
+    await new Promise(resolve => { const timeout = setTimeout(() => { previous.kill('SIGKILL'); }, 5000); previous.once('exit', () => { clearTimeout(timeout); resolve(); }); previous.kill('SIGTERM'); });
+  }
+  child = watchUsage(spawn(process.execPath, ['bot.mjs'], { cwd: target, env, stdio: ['ignore', 'pipe', 'pipe', 'ipc'], windowsHide: true, shell: false }));
+  child.stderr.on('data', () => {});
+  try { await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { child.kill(); reject(new Error('BOT_START_TIMEOUT')); }, 45000);
+    const failed = () => { clearTimeout(timer); reject(new Error('BOT_START_FAILED')); };
+    child.once('error', failed); child.once('exit', failed);
+    child.stdout.on('data', data => { if (data.toString().includes('Bot connecté :')) { clearTimeout(timer); child.off('exit', failed); child.off('error', failed); resolve(); } });
+  }); } catch (error) {
+    if (child.exitCode === null) child.kill();
+    if (previousId && previousId !== message.id) {
+      const previousTarget = path.join(home, 'releases', previousId);
+      await run(process.execPath, ['bot.mjs', '--deploy'], { cwd: previousTarget, env, stdio: 'ignore' }).catch(() => {});
+      child = watchUsage(spawn(process.execPath, ['bot.mjs'], { cwd: previousTarget, env, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true, shell: false }));
+      child.on('error', () => {});
+    }
+    throw error;
+  }
+  child.once('exit', () => { if (active === message.id) notify('failed'); });
+  active = message.id;
+  await save(path.join(home, 'active.json'), { id: message.id });
+  notify('running');
+}
+async function start(config) {
+  const lockPath = path.join(home, 'agent.lock');
+  if (await exists(lockPath)) {
+    const pid = Number(await readFile(lockPath, 'utf8'));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch (error) { if (error.code === 'EPERM') alive = true; }
+    if (alive) throw new Error('AGENT_ACTIVE');
+    await unlink(lockPath);
+  }
+  const lock = await open(lockPath, 'wx', 0o600);
+  await lock.writeFile(String(process.pid));
+  process.once('exit', () => {});
+  let stopped = false, shutdownBot = false, updating = false, activeSocket;
+  const shutdown = () => { stopped = true; shutdownBot = true; activeSocket?.close(); };
+  const localControl = message => { if (message?.type === 'shutdown') shutdown(); };
+  process.on('message', localControl);
+  process.on('SIGTERM', shutdown); process.on('SIGINT', shutdown);
+  if (process.connected) process.once('disconnect', shutdown);
+  usage = await createUsageCollector(home).catch(() => { usageReady = false; console.error('Statistiques locales indisponibles. Le bot continue à fonctionner.'); return { record() {}, acknowledge() {}, async flush() {} }; });
+  if (await exists(path.join(home, 'active.json'))) active = JSON.parse(await readFile(path.join(home, 'active.json'), 'utf8')).id;
+  let delay = 1000;
+  await mkdir(path.join(home, 'releases'), { recursive: true, mode: 0o700 });
+  // An existing bot is restarted locally even when the relay is unavailable.
+  if (await exists(path.join(home, 'active.json')) && await exists(secretPath) && !await exists(path.join(home, 'paused.json'))) {
+    const previous = JSON.parse(await readFile(path.join(home, 'active.json'), 'utf8'));
+    if (!/^[a-f0-9-]{36}$/.test(previous.id)) throw new Error('État local invalide.');
+    const secret = await credentials(config);
+    const target = path.join(home, 'releases', previous.id);
+    child = watchUsage(spawn(process.execPath, ['bot.mjs'], { cwd: target, env: { PATH: process.env.PATH, DISCORD_TOKEN: secret.token, DISCORD_CLIENT_ID: secret.applicationId }, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true, shell: false }));
+    child.on('error', () => {});
+    active = previous.id;
+  }
+  let pending = Promise.resolve();
+  while (!stopped) {
+    await new Promise(resolve => {
+      const socket = new WebSocket(`${config.relay.replace(/^https:/, 'wss:')}/v1/agents/${config.object}/socket`, { headers: { Authorization: `Bearer ${config.credential}` }, maxPayload: 512000 });
+      activeSocket = socket;
+      let heartbeat, usageTimer;
+      const send = value => { if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(value)); };
+      socket.on('open', async () => {
+        delay = 1000;
+        let profile;
+        if (await exists(secretPath)) {
+          try {
+            const secret = await credentials(config);
+            try { const response = await fetch('https://discord.com/api/v10/users/@me', { headers: { Authorization: 'Bot ' + secret.token }, signal: AbortSignal.timeout(15000) }); if (response.ok) { const user = await response.json(); profile = { id: user.id, username: user.username, avatar: user.avatar }; } } finally { secret.token = ''; }
+          } catch {}
+        }
+        send({ type: 'hello', agentVersion: AGENT_VERSION, updatesVersion: 1, protocol: 2, errorBranch: true, diagnosticsVersion: 2, optionsVersion: 1, conditionsVersion: 1, metricsVersion: usageReady ? 1 : 0, profile, running: Boolean(child && child.exitCode === null && !child.signalCode), hasToken: await exists(secretPath), deploymentId: active });
+        if (process.connected) process.send?.({ type: 'agent-ready' }, () => {});
+        await usage.flush(send).catch(() => console.error('Statistiques locales indisponibles.'));
+        usageTimer = setInterval(() => usage.flush(send).catch(() => console.error('Statistiques locales indisponibles.')), 60000);
+        heartbeat = setInterval(() => socket.ping(), 45000); console.log(`[${new Date().toISOString()}] Agent ${AGENT_VERSION} connecté.`);
+      });
+      socket.on('message', raw => {
+        pending = pending.then(async () => {
+          const message = JSON.parse(raw.toString());
+          if (message.type === 'update-available') { console.log('Une mise à jour de l’agent est disponible. Installez-la depuis Paramètres > Liaison du serveur.'); return; }
+          if (message.type === 'usage-ack') { usage.acknowledge(message.hour, message.revision); return; }
+          if (message.type === 'update') {
+            console.log(`[${new Date().toISOString()}] Mise à jour de l’agent demandée.`);
+            try {
+              await installUpdate(message.release, { home, currentVersion: AGENT_VERSION, source: path.dirname(fileURLToPath(import.meta.url)), report: state => { send({ type: 'update-status', state }); console.log(({ downloading: 'Téléchargement du paquet signé.', installing: 'Signature vérifiée. Installation de la mise à jour.', restarting: 'Installation vérifiée. Redémarrage de l’agent.' })[state]); } });
+              updating = true; stopped = true; shutdownBot = true; socket.close(1000, 'Mise à jour');
+            } catch { send({ type: 'update-status', state: 'failed' }); console.error('Mise à jour refusée ou échouée. La version actuelle est conservée.'); }
+          } else if (message.type === 'secret') {
+            try {
+              let profile;
+              if (!await exists(secretPath) || message.replace === true) {
+                const wasRunning = child && child.exitCode === null && !child.signalCode;
+                const previous = await exists(secretPath) ? await credentials(config) : null;
+                if (previous) previous.token = '';
+                profile = await acceptSecret(message.envelope, { agentId: config.agentId, previousApplicationId: previous?.applicationId, decrypt: async envelope => decrypt(envelope, await readFile(keyPath, 'utf8')), save: envelope => save(secretPath, envelope) });
+                send({ type: 'secret-ready', profile }); console.log('Configuration Discord validée et conservée localement.');
+                if (wasRunning) { try { await restartBot(config); send({ type: 'runtime-status', state: 'running' }); } catch { send({ type: 'runtime-status', state: 'failed' }); } }
+              } else send({ type: 'secret-ready' });
+            } catch { send({ type: 'secret-error' }); }
+          } else if (message.type === 'runtime') {
+            try {
+              console.log(message.command === 'stop' ? 'Arrêt du bot demandé.' : 'Démarrage ou redémarrage du bot demandé.');
+              if (message.command === 'stop') { await save(path.join(home, 'paused.json'), {}); await stopBot(); await usage.flush(send).catch(() => {}); send({ type: 'runtime-status', state: 'stopped' }); }
+              else if (message.command === 'restart') { await restartBot(config); if (await exists(path.join(home, 'paused.json'))) await unlink(path.join(home, 'paused.json')); send({ type: 'runtime-status', state: 'running' }); }
+            } catch { send({ type: 'runtime-status', state: 'failed' }); }
+          } else if (message.type === 'deploy') {
+            console.log(`[${new Date().toISOString()}] Nouveau déploiement reçu.`);
+            if (await exists(path.join(home, 'paused.json'))) await unlink(path.join(home, 'paused.json'));
+            try { await deploy(config, message, state => { send({ type: 'deployment-status', id: message.id, state }); console.log(({ received: 'Déploiement validé.', installing: 'Préparation du bot.', running: 'Déploiement terminé. Bot démarré.', failed: 'Échec du déploiement.' })[state] || 'État du déploiement modifié.'); }); }
+            catch { send({ type: 'deployment-status', id: message.id, state: 'failed' }); console.error('Déploiement refusé ou échoué.'); }
+          }
+        }).catch(() => console.error('Message refusé.'));
+      });
+      socket.on('error', () => {});
+      socket.on('close', code => { clearInterval(heartbeat); clearInterval(usageTimer); usage.flush().catch(() => {}); if (code === 4003) { stopped = true; console.error('Accès révoqué. Le bot local continue à fonctionner.'); } resolve(); });
+      socket.on('unexpected-response', (_, response) => { if (response.statusCode === 401) stopped = true; response.resume(); socket.terminate(); });
+    });
+    if (!stopped) { const until = Date.now() + delay + Math.random() * 1000; while (!stopped && Date.now() < until) await new Promise(resolve => setTimeout(resolve, 200)); }
+    delay = Math.min(delay * 2, 60000);
+  }
+  await pending;
+  if (shutdownBot) await stopBot();
+  await usage.flush().catch(() => {});
+  process.off('SIGTERM', shutdown); process.off('SIGINT', shutdown);
+  process.off('disconnect', shutdown); process.off('message', localControl);
+  await lock.close();
+  await unlink(lockPath);
+  if (updating) process.exitCode = 75;
+}
+function printHelp() {
+  console.log(`oft-agt ${AGENT_VERSION} — Node.js 22+
+  login | connect       Se connecter avec Discord et choisir le bot dans le navigateur
+  start | run           Démarrer en arrière-plan, sans ressaisir le token
+  stop                  Arrêter l’agent et son bot, conserver la configuration
+  restart               Redémarrer en arrière-plan
+  status                Afficher l’état local
+  logs                  Lire les 100 dernières lignes du journal
+  token [--stdin]       Régénérer l’authentification agent ; --stdin lit 64 caractères hexadécimaux
+  remove --yes          Révoquer la liaison et supprimer les données locales de cette instance
+  list                  Afficher les instances installées
+  help                  Afficher cette aide
+Options : --bot=IDENTIFIANT_COURT (voir list) pour choisir un bot ; start --foreground pour diagnostiquer.
+Après un redémarrage du serveur : start. La configuration est conservée sur disque.
+Documentation : https://doc-builder.oftone.fr/agent`);
+}
+async function main() {
+  const [requestedCommand, ...args] = process.argv.slice(2);
+  const command = requestedCommand || 'login';
+  const source = path.dirname(fileURLToPath(import.meta.url));
+  if (['help', '--help', '-h'].includes(command)) { printHelp(); return; }
+  if (command === 'list') { for (const instance of await listInstances(baseHome)) console.log(`${instance.agentId.slice(0, 8)} · ${(await localStatus(instance.home)).running ? 'actif' : 'arrêté'}`); return; }
+  if (command === 'daemon') { useHome(baseHome); return managedDaemon(home, source, args.find(arg => arg.startsWith('--run-id='))?.slice(9), supervise); }
+  if (command === 'check') { if (args.includes('--version=' + AGENT_VERSION)) return; throw new Error('UPDATE_CHECK'); }
+  if (command === 'worker') {
+    useHome(process.env.OFTONE_AGENT_HOME || baseHome);
+    await ensureLocalLauncher(home, source);
+    // A pre-0.4 supervisor can launch the updated worker after a dashboard update.
+    // Hand over before taking the worker lock, then let that foreground supervisor exit.
+    if (!process.env.OFTONE_MANAGED_DAEMON && !process.env.OFTONE_FOREGROUND) { await startBackground(home, source); console.log('Agent transféré en arrière-plan. Vous pouvez fermer ce terminal.'); return; }
+    return start(JSON.parse(await readFile(configPath, 'utf8')));
+  }
+  if (command === 'connect' || command === 'login') {
+    const values = Object.fromEntries(args.map(arg => { const index = arg.indexOf('='); return [arg.slice(2, index), arg.slice(index + 1)]; }));
+    let config, privateKey, pendingFile;
+    if (!values.token) { const authorization = await authorizeDevice(baseHome, { dashboard: values.dashboard, noOpen: args.includes('--no-open') }); ({ config, privateKey, pendingFile } = authorization); } else {
+    if (!values.relay && !values.object && /^[a-f0-9]{64}\.[a-f0-9]{64}$/.test(values.token || '')) {
+      [values.object, values.token] = values.token.split('.');
+      values.relay = 'https://oftone-agent-relay.hugocoutant2008.workers.dev';
+    }
+    let relay; try { relay = new URL(values.relay); } catch { throw new Error('PAIRING_INVALID'); }
+    if (relay.protocol !== 'https:' || relay.username || relay.password || relay.search || relay.pathname !== '/' || !/^[a-f0-9]{64}$/.test(values.object || '') || !/^[a-f0-9]{64}$/.test(values.token || '')) throw new Error('PAIRING_INVALID');
+    const keys = generateKeyPairSync('rsa', { modulusLength: 4096 });
+    const response = await fetch(`${relay.origin}/v1/agents/${values.object}/claim`, { method: 'POST', headers: { Authorization: `Bearer ${values.token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ publicKey: keys.publicKey.export({ format: 'jwk' }) }), signal: AbortSignal.timeout(20000) });
+    if (!response.ok) throw new Error('PAIRING_REJECTED');
+    const result = await response.json();
+    if (!/^[a-f0-9]{64}$/.test(result.token || '')) throw new Error('PAIRING_RESPONSE_INVALID');
+    config = { relay: relay.origin, object: values.object, agentId: result.agentId, credential: result.token };
+    privateKey = keys.privateKey.export({ type: 'pkcs8', format: 'pem' });
+    }
+    useHome(instanceDirectory(baseHome, config.object, config.agentId));
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    if (await exists(configPath)) { const previous = JSON.parse(await readFile(configPath, 'utf8')); if (previous.credential !== config.credential || previous.agentId !== config.agentId) throw new Error('INSTANCE_EXISTS'); }
+    await save(keyPath, privateKey);
+    await save(configPath, config);
+    const install = path.join(home, 'installation');
+    await mkdir(install, { recursive: true, mode: 0o700 });
+    const source = path.dirname(fileURLToPath(import.meta.url));
+    for (const entry of ['cli.mjs', 'instance.mjs', 'version.mjs', 'release-key.mjs', 'update.mjs', 'supervisor.mjs', 'secret.mjs', 'usage.mjs', 'compiler.mjs', 'compile-plan.mjs', 'package.json', 'npm-shrinkwrap.json', 'runtime', 'templates']) await cp(path.join(source, entry), path.join(install, entry), { recursive: true });
+    const modules = path.resolve(path.dirname(require.resolve('discord.js')), '../..');
+    await cp(modules, path.join(install, 'node_modules'), { recursive: true, filter: filename => path.resolve(filename) !== path.resolve(source) });
+    await rememberInstance(baseHome, config);
+    console.log('Agent lié : ' + config.agentId.slice(0, 8) + '.');
+    if (pendingFile) await unlink(pendingFile).catch(() => {});
+    if (args.includes('--foreground')) { process.env.OFTONE_FOREGROUND = '1'; return supervise(home, source); }
+    await startBackground(home, install); console.log('Agent démarré.'); return;
+  }
+  if (['run', 'start', 'stop', 'restart', 'status', 'logs', 'remove', 'token', 'upgrade'].includes(command)) {
+    const selector = args.find(arg => arg.startsWith('--bot='))?.slice(6) || args.find(arg => arg.startsWith('--instance='))?.slice('--instance='.length);
+    useHome(await resolveInstance(baseHome, path.dirname(fileURLToPath(import.meta.url)), selector));
+    if (selector) await rememberInstance(baseHome, JSON.parse(await readFile(configPath, 'utf8')));
+  }
+  if (command === 'upgrade') {
+    await stopBackground(home);
+    const source = path.dirname(fileURLToPath(import.meta.url));
+    const install = path.join(home, 'installation');
+    await mkdir(install, { recursive: true, mode: 0o700 });
+    if (path.resolve(source) !== path.resolve(install)) for (const entry of ['cli.mjs', 'instance.mjs', 'version.mjs', 'release-key.mjs', 'update.mjs', 'supervisor.mjs', 'secret.mjs', 'usage.mjs', 'compiler.mjs', 'compile-plan.mjs', 'package.json', 'npm-shrinkwrap.json', 'runtime', 'templates']) await cp(path.join(source, entry), path.join(install, entry), { recursive: true });
+    await save(path.join(home, 'agent-release.json'), { directory: 'installation' });
+    console.log('Agent mis à jour.');
+    if (args.includes('--foreground')) { process.env.OFTONE_FOREGROUND = '1'; return supervise(home, source); }
+    await startBackground(home, source); console.log('Agent démarré en arrière-plan.'); return;
+  }
+  if (['run', 'start', 'restart'].includes(command)) {
+    if (command === 'restart') await stopBackground(home);
+    await completeCredentialRotation(home, JSON.parse(await readFile(configPath, 'utf8')));
+    if (args.includes('--foreground')) { process.env.OFTONE_FOREGROUND = '1'; return supervise(home, source); }
+    await startBackground(home, source); console.log('Agent actif en arrière-plan. Aucun token à ressaisir.'); return;
+  }
+  if (command === 'stop') { await stopBackground(home); console.log('Agent arrêté. Sa configuration est conservée.'); return; }
+  if (command === 'status') { const state = await localStatus(home); console.log(state.legacy ? 'Agent actif au premier plan (ancienne installation).' : state.running ? 'Agent actif en arrière-plan.' : state.starting ? 'Agent en cours de démarrage.' : 'Agent arrêté.'); return; }
+  if (command === 'logs') { process.stdout.write(await readLogs(home)); return; }
+  if (command === 'token') {
+    const state = await localStatus(home); await stopBackground(home);
+    const config = JSON.parse(await readFile(configPath, 'utf8'));
+    let credential;
+    if (args.includes('--stdin')) { const chunks = []; let length = 0; for await (const chunk of process.stdin) { length += chunk.length; if (length > 128) throw new Error('AUTH_ROTATION_INVALID'); chunks.push(chunk); } credential = Buffer.concat(chunks).toString('utf8').trim(); }
+    await rotateCredential(home, config, credential);
+    if (state.daemon) await startBackground(home, source);
+    console.log('Token d’authentification remplacé et enregistré localement. Aucun token Discord modifié.'); return;
+  }
+  if (command === 'remove') {
+    if (!args.includes('--yes')) { console.log('Supprime l’agent sélectionné et ses données locales, y compris son token Discord. Relancez avec remove --yes pour confirmer.'); return; }
+    await stopBackground(home); const config = JSON.parse(await readFile(configPath, 'utf8'));
+    let revoked = false;
+    try { const response = await fetch(`${config.relay}/v1/agents/${config.object}/remove`, { method: 'POST', headers: { Authorization: `Bearer ${config.credential}` }, signal: AbortSignal.timeout(15000) }); revoked = response.ok; } catch {}
+    await removeLocalInstance(home, baseHome, config);
+    console.log('Agent sélectionné supprimé localement.' + (revoked ? ' Liaison révoquée.' : ' Dissociez aussi le serveur dans le dashboard si nécessaire.')); return;
+  }
+  throw new Error('COMMAND_UNKNOWN');
+}
+main().catch(error => { const messages = { LOGIN_BUSY: 'Une connexion Discord est déjà en cours sur cette machine.', LOGIN_EXPIRED: 'La demande a expiré. Relancez npx oft-agt login.', LOGIN_START_FAILED: 'Impossible de démarrer la connexion. Réessayez dans quelques minutes.', LOGIN_FAILED: 'Connexion refusée. Relancez npx oft-agt login.', AUTH_ROTATION_BUSY: 'Une modification de l’authentification est déjà en cours pour cette instance. Réessayez après sa fin.', COMMAND_UNKNOWN: 'Commande inconnue. Consultez oftone-agent help.', LEGACY_FOREGROUND: 'Un ancien agent fonctionne au premier plan. Arrêtez-le avec Ctrl+C une seule fois, puis utilisez start.', DAEMON_START_FAILED: 'L’agent n’a pas démarré. Consultez logs.', DAEMON_START_TIMEOUT: 'Démarrage non confirmé. Consultez status et logs avant de réessayer.', DAEMON_STOP_TIMEOUT: 'L’arrêt n’est pas encore confirmé. Consultez status et logs.', AUTH_ROTATION_FAILED: 'Changement d’authentification non confirmé. Réessayez token ou start pour reprendre sans perdre la liaison.', AUTH_ROTATION_INVALID: 'Token d’authentification invalide : 64 caractères hexadécimaux attendus.', PAIRING_INVALID: 'Commande de liaison invalide. Copiez à nouveau la commande complète depuis le dashboard.', PAIRING_REJECTED: 'Commande de liaison expirée, déjà utilisée ou révoquée. Générez-en une nouvelle depuis le bot concerné.', INSTANCE_INVALID: 'Identifiant d’instance invalide. Copiez la commande depuis les paramètres du bot concerné.', INSTANCE_NOT_FOUND: 'Cette liaison n’est pas installée sur cette machine. Utilisez la commande locale de cette instance ou configurez une nouvelle liaison.', INSTANCE_REQUIRED: 'Précisez l’instance avec la commande affichée dans les paramètres du bot ou la commande locale affichée à l’installation.', INSTANCE_EXISTS: 'Cette instance existe déjà. Utilisez sa commande locale de démarrage.', AGENT_ACTIVE: 'Cet agent est déjà actif. Arrêtez uniquement le processus de cette instance avant de le relancer.' }; console.error(messages[error.code || error.message] || 'Échec de l’agent. Vérifiez la liaison et la configuration locale. Aucun secret affiché.'); process.exitCode = 1; });
+

package/compile-plan.mjs

@@ -0,0 +1,133 @@
+import { isCondition, validateCondition } from './runtime/conditions.mjs';
+import { isOption, compileOptions } from './runtime/command-options.mjs';
+import { normalizeMessageConfig, messageConfigError } from './runtime/message-config.mjs';
+
+const ID = /^\d{17,20}$/;
+const plain = value => value && typeof value === 'object' && !Array.isArray(value);
+function fail(message) { throw new Error(message); }
+function text(value, name, max, required = false) {
+  if (typeof value !== 'string' || value.length > max || (required && !value.trim())) fail(`${name} : texte ${required ? 'non vide ' : ''}de ${max} caractères maximum attendu.`);
+  return value;
+}
+
+/** Pure JSON -> validated function call plan. No filesystem, network or code evaluation. */
+export function compile(input) {
+  if (!plain(input) || !Array.isArray(input.commands) || input.commands.length > 100) fail('commands doit être un tableau de 100 commandes maximum.');
+  const names = new Set();
+  const commands = input.commands.map((entry, commandIndex) => {
+    const command = Array.isArray(entry?.blocks) ? entry : entry?.config;
+    if (!plain(command)) fail(`Commande ${commandIndex + 1} : configuration absente.`);
+    const name = text(command.name ?? entry.name, 'Nom de commande', 32, true);
+    if (!/^[a-z0-9_-]{1,32}$/.test(name)) fail(`/${name} : utilisez des minuscules, chiffres, tirets ou underscores.`);
+    if (names.has(name)) fail(`Commande dupliquée : /${name}.`);
+    names.add(name);
+    const description = text(command.description ?? entry.description, `/${name} description`, 100, true);
+    if (!Array.isArray(command.blocks) || !command.blocks.length || command.blocks.length > 500 || !Array.isArray(command.edges)) fail(`/${name} : blocs ou liaisons invalides (500 blocs maximum).`);
+    const blocks = new Map();
+    for (const block of command.blocks) {
+      if (!plain(block) || typeof block.id !== 'string' || !block.id || block.id.length > 128 || blocks.has(block.id)) fail(`/${name} : identifiant de bloc absent, invalide ou dupliqué.`);
+      if (!isOption(block.type) && !isCondition(block.type) && !['root', 'errorRoot', 'conditionBranch', 'sendMessage', 'wait', 'deleteMessage'].includes(block.type)) fail(`/${name}/${block.id} : type de bloc inconnu : ${block.type}.`);
+      if (!plain(block.config || {})) fail(`/${name}/${block.id} : paramètres invalides.`);
+      blocks.set(block.id, block);
+    }
+    const roots = [...blocks.values()].filter(block => block.type === 'root');
+    if (roots.length !== 1) fail(`/${name} doit contenir exactement un bloc racine.`);
+    const errorRoots = [...blocks.values()].filter(block => block.type === 'errorRoot');
+    if (errorRoots.length > 1) fail(`/${name} : une seule racine d’erreur est autorisée.`);
+    const options = compileOptions(command.blocks);
+    const optionLinks = new Set();
+    const conditionConfigs = new Map([...blocks.values()].filter(block => isCondition(block.type)).map(block => [block.id, validateCondition(block.type, block.config)]));
+    const branchLinks = new Map();
+    const next = new Map();
+    const incoming = new Set();
+    for (const edge of command.edges) {
+      if (plain(edge) && isOption(blocks.get(edge.source)?.type)) {
+        if (edge.target !== roots[0].id || optionLinks.has(edge.source)) fail(`/${name} : chaque option doit être liée uniquement à la racine principale.`);
+        optionLinks.add(edge.source); continue;
+      }
+      if (plain(edge) && isOption(blocks.get(edge.target)?.type)) fail(`/${name} : une action ne peut pas être liée à une option.`);
+      if (!plain(edge) || !blocks.has(edge.source) || !blocks.has(edge.target) || ['root', 'errorRoot'].includes(blocks.get(edge.target)?.type)) fail(`/${name} : liaison invalide.`);
+      if (isCondition(blocks.get(edge.source).type)) {
+        const branch = blocks.get(edge.target);
+        const ruleId = branch.config?.ruleId;
+        const allowed = ['else', ...conditionConfigs.get(edge.source).rules.map(rule => rule.id)];
+        const linked = branchLinks.get(edge.source) || new Map();
+        if (branch.type !== 'conditionBranch' || branch.config.parentId !== edge.source || !allowed.includes(ruleId) || linked.has(ruleId) || incoming.has(edge.target)) fail(`/${name} : branche de condition invalide.`);
+        linked.set(ruleId, edge.target); branchLinks.set(edge.source, linked); incoming.add(edge.target); continue;
+      }
+      if (blocks.get(edge.target).type === 'conditionBranch') fail(`/${name} : les branches restent liées à leur condition.`);
+      if (next.has(edge.source)) fail(`/${name}/${edge.source} : plusieurs sorties ne sont pas encore prises en charge. Reliez les actions en séquence.`);
+      if (incoming.has(edge.target)) fail(`/${name}/${edge.target} : plusieurs entrées ne sont pas prises en charge.`);
+      next.set(edge.source, edge.target);
+      incoming.add(edge.target);
+    }
+    if (optionLinks.size !== options.length) fail(`/${name} : toutes les options doivent être liées à la racine.`);
+    for (const [id, config] of conditionConfigs) if (branchLinks.get(id)?.size !== config.rules.length + 1) fail(`/${name} : chaque condition nécessite ses branches et une branche Sinon.`);
+    const visited = new Set(options.map(option => option.id));
+    function compilePath(rootId, inheritedMessages = new Set(), inheritedWait = 0, depth = 0) {
+    if (depth > 32) fail(`/${name} : conditions imbriquées trop profondément (32 maximum).`);
+    const emittedMessages = new Set(inheritedMessages);
+    const calls = [];
+    let current = rootId;
+    let waitBudget = inheritedWait;
+    while (current) {
+      if (visited.has(current)) fail(`/${name} : boucle détectée.`);
+      visited.add(current);
+      const block = blocks.get(current);
+      const config = block.config || {};
+      let args;
+      let fn;
+      if (isCondition(block.type)) {
+        const branches = branchLinks.get(current);
+        const rules = conditionConfigs.get(current).rules;
+        calls.push({ id: current, fn: 'condition', args: { kind: block.type, rules }, branches: rules.map(rule => ({ id: branches.get(rule.id), ruleId: rule.id, calls: compilePath(branches.get(rule.id), emittedMessages, waitBudget, depth + 1) })), otherwise: { id: branches.get('else'), calls: compilePath(branches.get('else'), emittedMessages, waitBudget, depth + 1) } });
+      } else if (block.type === 'sendMessage') {
+        text(config.text ?? '', `/${name}/${current} message`, 2000);
+        if (config.embeds !== undefined && (!Array.isArray(config.embeds) || config.embeds.some(embed => !plain(embed)))) fail(`/${name}/${current} : embeds invalides.`);
+        const normal = normalizeMessageConfig(config);
+        if (!['reply', 'channel', 'dm'].includes(normal.sendMode)) fail(`/${name}/${current} : type d’envoi inconnu.`);
+        if (config.sendMode && config.replyMode && !['command', 'block', 'message'].includes(config.replyMode)) fail(`/${name}/${current} : mode de réponse inconnu.`);
+        if (config.channelMode && !['current', 'id'].includes(config.channelMode)) fail(`/${name}/${current} : mode de salon inconnu.`);
+        if (config.dmMode && !['author', 'id'].includes(config.dmMode)) fail(`/${name}/${current} : destinataire MP inconnu.`);
+        const error = messageConfigError(normal, command.blocks);
+        if (error) fail(`/${name}/${current} : ${error}`);
+        if (normal.sendMode === 'reply' && normal.replyMode === 'block' && !emittedMessages.has(normal.targetBlockId)) fail(`/${name}/${current} : le message cible doit être envoyé avant la réponse.`);
+        // Only accepted arguments are emitted; tokens and unrelated JSON properties are discarded.
+        args = Object.fromEntries(['text', 'embeds', 'sendMode', 'replyMode', 'targetBlockId', 'messageId', 'channelMode', 'channelId', 'dmMode', 'userId', 'ephemeral'].map(key => [key, normal[key]]));
+        args.embeds = normal.embeds.map(embed => ({
+          ...Object.fromEntries(['title', 'description', 'url', 'color', 'timestamp'].filter(key => embed[key] !== undefined).map(key => [key, embed[key]])),
+          ...(embed.author ? { author: Object.fromEntries(['name', 'url', 'icon_url'].filter(key => embed.author[key] !== undefined).map(key => [key, embed.author[key]])) } : {}),
+          ...(embed.footer ? { footer: Object.fromEntries(['text', 'icon_url'].filter(key => embed.footer[key] !== undefined).map(key => [key, embed.footer[key]])) } : {}),
+          ...(embed.image ? { image: { url: embed.image.url } } : {}),
+          ...(embed.thumbnail ? { thumbnail: { url: embed.thumbnail.url } } : {}),
+          ...(embed.fields ? { fields: embed.fields.map(field => ({ name: field.name, value: field.value, inline: Boolean(field.inline) })) } : {}),
+        }));
+        fn = 'sendMessage';
+        emittedMessages.add(current);
+      } else if (block.type === 'wait') {
+        const seconds = Number(config.seconds);
+        if (!Number.isFinite(seconds) || seconds < 0 || seconds > 300) fail(`/${name}/${current} : délai attendu entre 0 et 300 secondes.`);
+        waitBudget += seconds;
+        if (waitBudget > 840) fail(`/${name} : les délais cumulés dépassent 14 minutes.`);
+        fn = 'wait'; args = { seconds };
+      } else if (block.type === 'deleteMessage') {
+        const deleteMode = config.deleteMode || 'block';
+        if (!['block', 'manual'].includes(deleteMode)) fail(`/${name}/${current} : mode de suppression invalide.`);
+        if (deleteMode === 'block' && !emittedMessages.has(config.targetBlockId)) fail(`/${name}/${current} : le message à supprimer doit déjà avoir été envoyé.`);
+        if (deleteMode === 'manual' && !ID.test(config.messageId || '') && !/^\{[a-z0-9_-]+_option(?:_id)?\}$/.test(config.messageId || '')) fail(`/${name}/${current} : ID de message invalide.`);
+        fn = 'deleteMessage'; args = deleteMode === 'block' ? { deleteMode, targetBlockId: config.targetBlockId } : { deleteMode, messageId: config.messageId };
+      }
+      if (fn) calls.push({ id: current, fn, args });
+      current = next.get(current);
+    }
+    return calls;
+    }
+    const calls = compilePath(roots[0].id);
+    const errorCalls = errorRoots.length ? compilePath(errorRoots[0].id) : undefined;
+    if (visited.size !== blocks.size) fail(`/${name} : blocs non reliés à une racine ou boucle dans une partie non accessible.`);
+    if (!calls.length || (errorCalls && !errorCalls.length)) fail(`/${name} : ajoutez au moins une action à chaque racine.`);
+    return { name, description, ...(options.length ? { options } : {}), calls, ...(errorCalls ? { errorCalls } : {}) };
+  });
+  return JSON.parse(JSON.stringify({ schemaVersion: 1, bot: { name: typeof input.bot?.name === 'string' ? input.bot.name.slice(0, 100) : 'Oftone Bot' }, commands }));
+}
+

package/compiler.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { readFile, writeFile, mkdir, cp, access } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { compile } from './compile-plan.mjs';
+export { compile } from './compile-plan.mjs';
+function fail(message) { throw new Error(message); }
+
+const ROOT = path.dirname(fileURLToPath(import.meta.url));
+/** Emit a standalone Node.js project. Refuse to replace an existing directory. */
+export async function writeBot(input, outputDirectory) {
+  const plan = compile(input);
+  const output = path.resolve(outputDirectory);
+  try { await access(output); fail(`Le dossier de sortie existe déjà : ${output}`); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  await mkdir(output, { recursive: false });
+  await cp(path.join(ROOT, 'runtime'), path.join(output, 'runtime'), { recursive: true });
+  await cp(path.join(ROOT, 'templates/bot.mjs'), path.join(output, 'bot.mjs'));
+  await writeFile(path.join(output, 'plan.json'), JSON.stringify(plan, null, 2) + '\n');
+  await writeFile(path.join(output, 'package.json'), JSON.stringify({ name: 'oftone-generated-bot', version: '1.0.0', private: true, type: 'module', engines: { node: '>=22' }, scripts: { start: 'node --env-file=.env bot.mjs', deploy: 'node --env-file=.env bot.mjs --deploy' }, dependencies: { 'discord.js': '^14.14.0' } }, null, 2) + '\n');
+  await writeFile(path.join(output, '.env.example'), '# Token saisi uniquement sur votre serveur.\nDISCORD_TOKEN=\n# Application ID Discord (pas l’identifiant du projet Builder).\nDISCORD_CLIENT_ID=\n# Optionnel : serveur de test. Vide = commandes globales.\nDISCORD_GUILD_ID=\n');
+  await writeFile(path.join(output, '.gitignore'), '.env\nnode_modules/\n');
+  return { output, plan };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (!args.length || args.includes('--help')) {
+    console.log('Oftone Compiler\n  node compiler.mjs <builder.json> --out <nouveau-dossier>\n  node compiler.mjs --stdin --out <nouveau-dossier>\n  node compiler.mjs <builder.json> --check\n\nAucun token requis. --stdin permet une invocation par un futur service.');
+    return;
+  }
+  const allowed = new Set(['--stdin', '--check', '--out']);
+  for (const arg of args) if (arg.startsWith('--') && !allowed.has(arg)) fail(`Option inconnue : ${arg}`);
+  let source;
+  if (args[0] === '--stdin') {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of process.stdin) {
+      size += chunk.length;
+      if (size > 5 * 1024 * 1024) fail('Le JSON dépasse 5 Mo.');
+      chunks.push(chunk);
+    }
+    source = Buffer.concat(chunks).toString('utf8');
+  } else source = await readFile(args[0], 'utf8');
+  if (Buffer.byteLength(source) > 5 * 1024 * 1024) fail('Le JSON dépasse 5 Mo.');
+  const input = JSON.parse(source);
+  if (args.includes('--check')) { const plan = compile(input); console.log(`JSON valide : ${plan.commands.length} commande(s).`); return; }
+  const outIndex = args.indexOf('--out');
+  if (outIndex < 0 || !args[outIndex + 1] || args[outIndex + 1].startsWith('--')) fail('Précisez --out <nouveau-dossier>.');
+  const { output, plan } = await writeBot(input, args[outIndex + 1]);
+  console.log(`Bot généré : ${output}\n${plan.commands.length} commande(s). Renseignez .env, puis npm install et npm run deploy avant npm start.`);
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch(error => { console.error(`Compilation refusée : ${error.message}`); process.exitCode = 1; });
+}

package/instance.mjs

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { readFile, writeFile, rename, access, readdir } from 'node:fs/promises';
+
+export async function rememberInstance(base, config) {
+  instanceDirectory(base, config.object, config.agentId);
+  const file = path.join(base, 'active-instance.json');
+  await writeFile(file + '.tmp', JSON.stringify({ object: config.object, agentId: config.agentId }), { mode: 0o600 });
+  await rename(file + '.tmp', file);
+}
+
+export async function listInstances(base) {
+  const result = [];
+  try { const config = JSON.parse(await readFile(path.join(base, 'agent.json'), 'utf8')); if (OBJECT.test(config.object) && AGENT.test(config.agentId)) result.push({ home: base, object: config.object, agentId: config.agentId }); } catch {}
+  let objects = []; try { objects = await readdir(path.join(base, 'instances'), { withFileTypes: true }); } catch {}
+  for (const object of objects.filter(entry => entry.isDirectory() && OBJECT.test(entry.name))) {
+    for (const agent of await readdir(path.join(base, 'instances', object.name), { withFileTypes: true })) {
+      if (!agent.isDirectory() || !AGENT.test(agent.name)) continue;
+      const home = instanceDirectory(base, object.name, agent.name);
+      try { const config = JSON.parse(await readFile(path.join(home, 'agent.json'), 'utf8')); if (config.object === object.name && config.agentId === agent.name) result.push({ home, object: object.name, agentId: agent.name }); } catch {}
+    }
+  }
+  return result;
+}
+
+const OBJECT = /^[a-f0-9]{64}$/;
+const AGENT = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+export function instanceDirectory(base, object, agentId) {
+  if (!OBJECT.test(object || '') || !AGENT.test(agentId || '')) throw new Error('INSTANCE_INVALID');
+  return path.join(base, 'instances', object, agentId);
+}
+export async function resolveInstance(base, source, selector) {
+  if (selector && /^[a-f0-9]{8}$/.test(selector)) { const matches = (await listInstances(base)).filter(item => item.agentId.startsWith(selector)); if (matches.length !== 1) throw new Error('INSTANCE_NOT_FOUND'); return matches[0].home; }
+  if (selector) {
+    const [object, agentId, extra] = selector.split('.');
+    if (extra !== undefined) throw new Error('INSTANCE_INVALID');
+    const directory = instanceDirectory(base, object, agentId);
+    try { await access(path.join(directory, 'agent.json')); return directory; } catch {}
+    // Existing installations stay usable when upgraded with the scoped dashboard command.
+    try {
+      const legacy = JSON.parse(await readFile(path.join(base, 'agent.json'), 'utf8'));
+      if (legacy.object === object && legacy.agentId === agentId) return base;
+    } catch {}
+    throw new Error('INSTANCE_NOT_FOUND');
+  }
+  if (path.basename(source) === 'installation') {
+    const installedHome = path.dirname(source);
+    try { await access(path.join(installedHome, 'agent.json')); return installedHome; } catch {}
+  }
+  if (path.basename(path.dirname(source)) === 'versions') {
+    const installedHome = path.dirname(path.dirname(source));
+    try { await access(path.join(installedHome, 'agent.json')); return installedHome; } catch {}
+  }
+  const instances = await listInstances(base);
+  if (instances.length === 1) return instances[0].home;
+  try {
+    const active = JSON.parse(await readFile(path.join(base, 'active-instance.json'), 'utf8'));
+    const match = instances.find(item => item.object === active.object && item.agentId === active.agentId);
+    if (match) return match.home;
+  } catch {}
+  throw new Error('INSTANCE_REQUIRED');
+}