oft-agt 0.5.1 → 0.5.8

package/README.md

@@ -0,0 +1,36 @@
+# Oftone Server Agent
+
+Agent Node.js 22+ de liaison avec le dashboard. Le relais est hébergé sur Cloudflare Workers avec un Durable Object SQLite ; les bots Discord s’exécutent sur le serveur utilisateur.
+
+Générez la commande d’installation depuis **Liaison du serveur** dans le dashboard. Elle utilise un token à usage unique de dix minutes, puis l’agent dispose de sa propre identité. Exécutez-la avec un compte système dédié, sans privilèges administrateur.
+
+Les fichiers privés et l’installation persistante se trouvent par défaut dans `~/.oftone-agent`. La variable `OFTONE_AGENT_HOME` permet de choisir un autre dossier, notamment pour héberger un deuxième bot. Ne partagez jamais le dossier privé entre utilisateurs.
+
+Après installation, l’agent affiche la commande locale pour redémarrer sans télécharger le paquet :
+
+```text
+node <dossier-utilisateur>/.oftone-agent/installation/cli.mjs run
+```
+
+Le processus doit rester actif. Cette version n’installe pas de service système de démarrage automatique. Une coupure du réseau Cloudflare n’arrête pas le bot déjà lancé.
+
+Le token Discord est configuré depuis le dashboard après liaison, chiffré pour la clé publique de cet agent et conservé localement sous forme d’enveloppe chiffrée. La clé privée locale permet au processus de le déchiffrer pour lancer le bot. Les permissions du compte système restent essentielles ; sous Windows, vérifier les ACL du dossier.
+
+Le bouton **Déployer** transmet un snapshot des commandes enregistrées. L’agent valide ce JSON, le compile avec les fonctions embarquées et démarre une version locale. Aucun JavaScript, script shell ou paquet npm fourni par le JSON n’est exécuté. Les dépendances proviennent du paquet de l’agent, verrouillées par `npm-shrinkwrap.json`.
+
+La commande de déploiement remplace les slash commands de l’application Discord : utiliser une application dédiée. Les changements de token et la rotation de l’identité de l’agent restent à compléter. Les processus des bots ne sont pas encore isolés dans des conteneurs.
+
+Pour reconstruire le paquet : `npm pack --ignore-scripts`. Le dossier du builder contient `server-link/README.md`, les tests du relais et la configuration Wrangler. Le paquet public est servi par le Worker ; aucun envoi au registre npm n’est nécessaire.
+
+
+## Version 0.5.2
+
+Les envois vers un salon vérifient désormais le serveur et les droits de
+l’utilisateur, ainsi que l’appartenance aux fils privés. Le moteur adapte sa
+concurrence à la charge CPU globale du PC, à la mémoire disponible et à sa
+réactivité. Les pauses libèrent une place de traitement ; la file et les
+invocations conservées restent bornées pour protéger l’hébergement.
+
+Installation : `npm install -g oft-agt` (Node.js 22 ou supérieur).
+La mise à jour du paquet npm ne remplace pas automatiquement les installations
+persistantes déjà liées dans le dossier privé de l’agent.

package/cli.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/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';
@@ -13,9 +13,9 @@ 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 { instanceDirectory, resolveInstance, listInstances, rememberInstance } from './instance.mjs';
 import { AGENT_VERSION } from './version.mjs';
-import { installUpdate } from './update.mjs';
+import { installOfficialUpdate } from './update.mjs';
 import { supervise } from './supervisor.mjs';
 
 const baseHome = process.env.OFTONE_AGENT_HOME || path.join(homedir(), '.oftone-agent');
@@ -56,7 +56,7 @@ async function restartBot(config) {
   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 }));
+  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, OFTONE_VARIABLES_PATH: path.join(home, 'data', 'variables.sqlite') }, 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(); } }); });
@@ -80,6 +80,7 @@ async function deploy(config, message, notify) {
   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];
+  env.OFTONE_VARIABLES_PATH = path.join(home, 'data', 'variables.sqlite');
   await run(process.execPath, ['bot.mjs', '--deploy'], { cwd: target, env, stdio: 'ignore' });
   const previous = child;
   const previousId = active;
@@ -136,7 +137,7 @@ async function start(config) {
     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 = watchUsage(spawn(process.execPath, ['bot.mjs'], { cwd: target, env: { PATH: process.env.PATH, DISCORD_TOKEN: secret.token, DISCORD_CLIENT_ID: secret.applicationId, OFTONE_VARIABLES_PATH: path.join(home, 'data', 'variables.sqlite') }, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true, shell: false }));
     child.on('error', () => {});
     active = previous.id;
   }
@@ -156,7 +157,7 @@ async function start(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 });
+        send({ type: 'hello', agentVersion: AGENT_VERSION, updatesVersion: 1, officialUpdatesVersion: 1, protocol: 2, errorBranch: true, diagnosticsVersion: 2, optionsVersion: 1, conditionsVersion: 1, eventsVersion: 1, complementaryBlocksVersion: 1, discordActionsVersion: 1, messageButtonsVersion: 2, variablesVersion: Number(process.versions.node.split('.')[0]) > 22 || (Number(process.versions.node.split('.')[0]) === 22 && Number(process.versions.node.split('.')[1]) >= 5) ? 1 : 0, 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);
@@ -170,7 +171,7 @@ async function start(config) {
           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]); } });
+              await installOfficialUpdate(message.version || message.release?.version, { 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') {
@@ -276,16 +277,16 @@ async function main() {
     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) + '.');
+    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;
+    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 (selector) await rememberInstance(baseHome, JSON.parse(await readFile(configPath, 'utf8')));
   }
   if (command === 'upgrade') {
     await stopBackground(home);

package/compile-plan.mjs

@@ -1,133 +1,305 @@
+import { validateEventGraph } from './runtime/events.mjs';
+import { isVariableBlock, validateVariableBlock, validateVariableDefinitions } from './runtime/custom-variables.mjs';
+import { validateButton } from './runtime/message-buttons.mjs';
+import { isDiscordBlock, validateDiscordBlock } from './runtime/discord-blocks.mjs';
+
 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 variableDefinitions = validateVariableDefinitions(input.variableDefinitions || []);
+  const variableDeletions = (input.variableDeletions || []).map(item => { if (!item || typeof item.id !== 'string' || !/^[A-Za-z0-9_-]{1,100}$/.test(item.id) || typeof item.purge !== 'boolean') fail('Suppression de variable invalide.'); return { id: item.id, purge: item.purge }; });
+  if (variableDeletions.length > 10000) fail('Trop de suppressions de variables.');
   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.`);
+
+    validateEventGraph(command);
     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 (!isVariableBlock(block.type) && !isDiscordBlock(block.type) && !isOption(block.type) && !isCondition(block.type) && !['root', 'errorRoot', 'conditionBranch', 'messageButton', '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 buttonLinks=new Map();
+    const buttonBranches=[];
     const next = new Map();
+
     const incoming = new Set();
+
     for (const edge of command.edges) {
+      if (blocks.get(edge?.target)?.type==='messageButton') {
+        const child=blocks.get(edge.target);
+        if(blocks.get(edge.source)?.type!=='sendMessage'||child.config.parentId!==edge.source||incoming.has(edge.target)) fail('Un bouton reste lié à son message.');
+        const list=buttonLinks.get(edge.source)||[];list.push(child);buttonLinks.set(edge.source,list);incoming.add(edge.target);continue;
+      }
+      if(blocks.get(edge?.source)?.type==='messageButton'&&Number(blocks.get(edge.source).config.style||1)>=5) fail('Un bouton lien ou achat ne déclenche pas de blocs.');
+
       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.`);
+
+    for(const block of blocks.values()) if(block.type==='messageButton'&&!incoming.has(block.id))fail('Bouton détaché de son message.');
+    for(const list of buttonLinks.values()) {
+      const rows=[0,0,0,0,0]; if(list.length>25)fail('25 boutons maximum par message.');
+      for(const b of list){const c=validateButton(b.config);if(++rows[c.row]>5)fail('5 boutons maximum par ligne.');}
+    }
     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 (isVariableBlock(block.type)) {
+        fn = block.type; args = validateVariableBlock(block.type, config, variableDefinitions);
+      } else if (isDiscordBlock(block.type)) {
+
+        fn = block.type; args = validateDiscordBlock(block.type,config);
+
+        if (block.type === 'createChannel') emittedMessages.add(current);
+
       } 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.channelMode && !['current', 'id', 'created'].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 (normal.channelMode === 'created' && (!emittedMessages.has(normal.createdChannelBlockId) || blocks.get(normal.createdChannelBlockId)?.type !== 'createChannel')) fail('Le salon créé doit provenir d’un bloc exécuté avant ce message.');
+
+        const error = messageConfigError({...normal,buttons:buttonLinks.get(current)}, 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 = Object.fromEntries(['text', 'embeds', 'sendMode', 'replyMode', 'targetBlockId', 'messageId', 'channelMode', 'channelId', 'createdChannelBlockId', '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);
+        const children=buttonLinks.get(current)||[];
+        if(children.length) args.buttons=children.map(child=>({id:child.id,config:validateButton(child.config)}));
+        for(const child of children){
+          const config=validateButton(child.config);
+          const childCalls=compilePath(child.id,emittedMessages,0,depth+1);
+          buttonBranches.push({id:child.id,parentId:current,config,calls:childCalls});
+        }
+
       } 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 === 'block' && (!emittedMessages.has(config.targetBlockId) || blocks.get(config.targetBlockId)?.type !== 'sendMessage')) 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 { name, description, ...(command.trigger ? {trigger:command.trigger} : {}), ...(options.length ? { options } : {}), calls, ...(buttonBranches.length?{buttonBranches}:{}), ...(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 }));
+
+  return JSON.parse(JSON.stringify({ schemaVersion: 1, ...(input.variableDefinitions !== undefined ? { variableDefinitions, variableDeletions } : {}), bot: { name: typeof input.bot?.name === 'string' ? input.bot.name.slice(0, 100) : 'Oftone Bot' }, commands }));
+
 }
 
+
+

package/compiler.mjs

@@ -1,55 +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; });
-}
+#!/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.5.0' }, 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/\ndata/\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; });
+}