oft-agt 0.5.0 → 0.5.7

package/runtime/message-config.mjs

@@ -1,73 +1,150 @@
 export function normalizeMessageConfig(config = {}) {
+
   const legacyChannel = !config.sendMode && config.replyMode === 'manual';
+
   return {
+
     ...config,
+
     text: config.text || '',
+
     embeds: Array.isArray(config.embeds) ? config.embeds : [],
+
     sendMode: config.sendMode || (legacyChannel ? 'channel' : 'reply'),
+
     replyMode: ['block', 'message'].includes(config.replyMode) ? config.replyMode : 'command',
+
     targetBlockId: config.targetBlockId || '',
+
     messageId: config.messageId || '',
+
     channelMode: config.channelMode || (legacyChannel ? 'id' : 'current'),
+
+    createdChannelBlockId: config.createdChannelBlockId || '',
+
     channelId: config.channelId || (legacyChannel ? config.replyTarget || '' : ''),
+
     dmMode: config.dmMode || 'author',
+
     userId: config.userId || '',
+
     ephemeral: Boolean(config.ephemeral),
+
   };
+
 }
 
+
+
 export function safeMessageUrl(value) {
+
   if (!value) return '';
+
   try {
+
     const url = new URL(value);
+
     return ['https:', 'http:'].includes(url.protocol) ? url.href : '';
+
   } catch { return ''; }
+
 }
 
+
+
 export function messageConfigError(raw, nodes, allowVariables = true) {
+
   const config = normalizeMessageConfig(raw);
-  if (!config.text.trim() && !config.embeds.length) return 'Ajoutez du texte ou un embed au message.';
+
+  if (!config.text.trim() && !config.embeds.length && !config.buttons?.length) return 'Ajoutez du texte ou un embed au message.';
+
   if (config.text.length > 2000) return 'Le message est limité à 2 000 caractères.';
+
   if (config.embeds.length > 5) return 'Vous pouvez ajouter au maximum 5 embeds.';
+
   let total = 0;
+
   for (const [index, embed] of config.embeds.entries()) {
+
     const fields = embed.fields || [];
+
     const texts = [embed.title || '', embed.description || '', embed.author?.name || '', embed.footer?.text || ''];
+
     if (!texts.some(Boolean) && !embed.image?.url && !embed.thumbnail?.url && !fields.length) return `Complétez l’embed ${index + 1} ou supprimez-le.`;
+
     if (texts[0].length > 256 || texts[1].length > 4096 || texts[2].length > 256 || texts[3].length > 2048) return `Un texte de l’embed ${index + 1} dépasse la limite autorisée.`;
+
     if (fields.length > 25 || fields.some(field => !field.name?.trim() || !field.value?.trim() || field.name.length > 256 || field.value.length > 1024)) return `Vérifiez les champs de l’embed ${index + 1} (nom et valeur requis).`;
+
     if (embed.color && !/^#[a-f\d]{6}$/i.test(embed.color) && !(Number.isInteger(embed.color) && embed.color >= 0 && embed.color <= 0xffffff)) return `Vérifiez la couleur de l’embed ${index + 1}.`;
+
     for (const url of [embed.url, embed.author?.url, embed.author?.icon_url, embed.footer?.icon_url, embed.image?.url, embed.thumbnail?.url]) {
-      const previewUrl = allowVariables && typeof url === 'string' ? url.replace(/\{[a-z0-9_-]+_option(?:_(?:id|name|displayName|avatar))?\}/g, 'https://example.com') : url;
+
+      const previewUrl = allowVariables && typeof url === 'string' ? url.replace(/\{[a-zA-Z0-9_-]+\}/g, 'https://example.com') : url;
+
       if (url && !safeMessageUrl(previewUrl)) return `Utilisez une URL http ou https valide dans l’embed ${index + 1}.`;
+
     }
+
     if ((embed.author?.url || embed.author?.icon_url) && !embed.author?.name) return `Renseignez le nom de l’auteur dans l’embed ${index + 1}.`;
+
     if (embed.footer?.icon_url && !embed.footer?.text) return `Renseignez le pied de page dans l’embed ${index + 1}.`;
+
     total += texts.reduce((sum, text) => sum + text.length, 0) + fields.reduce((sum, field) => sum + field.name.length + field.value.length, 0);
+
   }
+
   if (total > 6000) return 'L’ensemble des embeds est limité à 6 000 caractères.';
+
   if (config.sendMode === 'reply' && config.replyMode === 'block' && (!config.targetBlockId || (nodes && !nodes.some(node => (node.id === config.targetBlockId && (node.type === 'sendMessage' || node.data?.kind === 'message')))))) return 'Choisissez un bloc de message existant.';
+
+  if (config.sendMode === 'channel' && config.channelMode === 'created' && (!config.createdChannelBlockId || (nodes && !nodes.some(n=>n.id===config.createdChannelBlockId && (n.type==='createChannel'||n.data?.kind==='createChannel'))))) return 'Choisissez un bloc de création de salon.';
+
   const needsId = config.sendMode === 'reply' && config.replyMode === 'message' ? config.messageId : config.sendMode === 'channel' && config.channelMode === 'id' ? config.channelId : config.sendMode === 'dm' && config.dmMode === 'id' ? config.userId : null;
-  if (needsId !== null && !/^\d{17,20}$/.test(needsId) && !(allowVariables && /^\{[a-z0-9_-]+_option(?:_id)?\}$/.test(needsId))) return 'Renseignez un ID Discord valide (17 à 20 chiffres).';
+
+  if (needsId !== null && !/^\d{17,20}$/.test(needsId) && !(allowVariables && /^\{[a-zA-Z0-9_-]+\}$/.test(needsId))) return 'Renseignez un ID Discord valide (17 à 20 chiffres).';
+
   return '';
+
 }
 
+
+
 export function discordMessagePayload(raw) {
+
   const config = normalizeMessageConfig(raw);
+
   return {
+
     ...(config.text ? { content: config.text } : {}),
+
     allowedMentions: { parse: [] },
+
     embeds: config.embeds.map(embed => ({
+
       ...(embed.title ? { title: embed.title } : {}),
+
       ...(embed.description ? { description: embed.description } : {}),
+
       ...(safeMessageUrl(embed.url) ? { url: safeMessageUrl(embed.url) } : {}),
+
       ...(embed.color !== undefined && embed.color !== '' ? { color: typeof embed.color === 'number' ? embed.color : parseInt(embed.color.slice(1), 16) } : {}),
+
       ...(embed.author?.name ? { author: { name: embed.author.name, ...(safeMessageUrl(embed.author.url) ? { url: safeMessageUrl(embed.author.url) } : {}), ...(safeMessageUrl(embed.author.icon_url) ? { icon_url: safeMessageUrl(embed.author.icon_url) } : {}) } } : {}),
+
       ...(embed.footer?.text ? { footer: { text: embed.footer.text, ...(safeMessageUrl(embed.footer.icon_url) ? { icon_url: safeMessageUrl(embed.footer.icon_url) } : {}) } } : {}),
+
       ...(safeMessageUrl(embed.image?.url) ? { image: { url: safeMessageUrl(embed.image.url) } } : {}),
+
       ...(safeMessageUrl(embed.thumbnail?.url) ? { thumbnail: { url: safeMessageUrl(embed.thumbnail.url) } } : {}),
+
       ...(embed.fields?.length ? { fields: embed.fields } : {}),
+
       ...(embed.timestamp ? { timestamp: new Date().toISOString() } : {}),
+
     })),
+
   };
+
 }
+

package/runtime/scheduler.mjs

@@ -0,0 +1,91 @@
+import os from 'node:os';
+import v8 from 'node:v8';
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+
+const MB = 1024 * 1024;
+export function busyError() { return Object.assign(new Error('Le bot est occupé. Réessayez dans quelques instants.'), { code: 'BOT_BUSY' }); }
+
+/** Global CPU includes other applications; available memory and event-loop lag
+ * constrain concurrency. A separate bound includes queued and sleeping commands. */
+export function createResourceSampler() {
+  const totals = () => os.cpus().reduce((sum, cpu) => {
+    sum.idle += cpu.times.idle;
+    sum.total += Object.values(cpu.times).reduce((a, b) => a + b, 0);
+    return sum;
+  }, { idle: 0, total: 0 });
+  let previous = totals();
+  const lag = monitorEventLoopDelay({ resolution: 20 }); lag.enable();
+  const sample = () => {
+    const current = totals(), elapsed = current.total - previous.total;
+    const cpu = elapsed > 0 ? 1 - (current.idle - previous.idle) / elapsed : 0;
+    previous = current;
+    const free = Math.min(os.freemem(), process.availableMemory?.() ?? Infinity);
+    const memory = process.memoryUsage(), heap = v8.getHeapStatistics();
+    const result = { cpu, lagMs: Number(lag.percentile(95)) / 1e6, free,
+      heapRatio: memory.heapUsed / heap.heap_size_limit, cores: os.availableParallelism() };
+    lag.reset(); return result;
+  };
+  sample.close = () => lag.disable();
+  return sample;
+}
+
+export class AdaptiveScheduler {
+  constructor({ sample = createResourceSampler(), intervalMs = 1000, queueTimeoutMs = 30000 } = {}) {
+    this.sample = sample; this.queueTimeoutMs = queueTimeoutMs;
+    this.limit = 4; this.active = 0; this.retained = 0; this.capacity = 32;
+    this.queue = []; this.healthy = 0; this.pressure = false; this.closed = false;
+    this.refresh();
+    if (intervalMs) { this.timer = setInterval(() => this.refresh(), intervalMs); this.timer.unref(); }
+  }
+  refresh() {
+    const s = this.sample();
+    const headroom = Math.max(0, s.free - 256 * MB);
+    const ceiling = Math.max(1, Math.min(256, s.cores * 16, Math.floor(headroom / (16 * MB))));
+    this.capacity = Math.max(8, Math.min(1024, Math.floor(headroom / (2 * MB))));
+    this.pressure = s.free < 128 * MB || s.heapRatio > 0.85;
+    if (this.pressure || s.cpu > 0.9 || s.lagMs > 100) {
+      this.limit = Math.max(1, Math.floor(this.limit / 2)); this.healthy = 0;
+    } else if (s.cpu < 0.75 && s.lagMs < 40 && s.heapRatio < 0.7) {
+      if (++this.healthy >= 3) { this.limit++; this.healthy = 0; }
+    } else this.healthy = 0;
+    this.limit = Math.min(this.limit, ceiling);
+    this.drain();
+  }
+  admit() {
+    if (this.closed || this.pressure || this.retained >= this.capacity) throw busyError();
+    this.retained++;
+    let released = false;
+    return () => { if (!released) { released = true; this.retained--; } };
+  }
+  run(task, { signal } = {}) {
+    if (this.closed || signal?.aborted) return Promise.reject(signal?.reason || busyError());
+    return new Promise((resolve, reject) => {
+      const entry = { task, resolve, reject, signal };
+      const cancel = reason => {
+        const index = this.queue.indexOf(entry);
+        if (index < 0) return;
+        this.queue.splice(index, 1); entry.cleanup(); reject(reason);
+      };
+      entry.abort = () => cancel(signal.reason);
+      entry.timer = setTimeout(() => cancel(busyError()), this.queueTimeoutMs);
+      entry.cleanup = () => { clearTimeout(entry.timer); signal?.removeEventListener('abort', entry.abort); };
+      signal?.addEventListener('abort', entry.abort, { once: true });
+      this.queue.push(entry); this.drain();
+    });
+  }
+  drain() {
+    while (!this.closed && !this.pressure && this.active < this.limit && this.queue.length) {
+      const entry = this.queue.shift(); entry.cleanup();
+      if (entry.signal?.aborted) { entry.reject(entry.signal.reason); continue; }
+      this.active++;
+      Promise.resolve().then(() => { entry.signal?.throwIfAborted(); return entry.task(); }).then(entry.resolve, entry.reject).finally(() => { this.active--; this.drain(); });
+    }
+  }
+  close() {
+    this.closed = true; clearInterval(this.timer); this.sample.close?.();
+    for (const entry of this.queue.splice(0)) { entry.cleanup(); entry.reject(busyError()); }
+  }
+}
+
+let scheduler;
+export function getScheduler() { return scheduler ||= new AdaptiveScheduler(); }

package/runtime/variable-actions.mjs

@@ -0,0 +1,42 @@
+import { interpolateVariables, validateVariableBlock, parseVariableLines } from './custom-variables.mjs';
+
+export function variableRuntimeOptions(context, base, definitions, store, warn = () => {}) {
+  const target = async (definition, params = {}) => {
+    const current = { guildId: context.interaction.guildId, channelId: context.interaction.channelId, userId: context.interaction.user?.id };
+    const next = { guildId: params.server || current.guildId, channelId: params.channel || current.channelId, userId: params.user || current.userId };
+    if (definition.scope === 'guild' && next.guildId !== current.guildId) {
+      const guild = await context.client.guilds.fetch(next.guildId);
+      const member = await guild.members.fetch({ user: current.userId, force: true });
+      if (!member.permissions.has('ManageGuild')) throw Error('Contexte de variable inaccessible.');
+    }
+    if (['channel', 'channelUser'].includes(definition.level) && (next.channelId !== current.channelId || next.guildId !== current.guildId)) {
+      const channel = await context.client.channels.fetch(next.channelId);
+      if (!channel || channel.guildId !== next.guildId) throw Error('Contexte de variable inaccessible.');
+      const member = await channel.guild.members.fetch({ user: current.userId, force: true });
+      if (!channel.permissionsFor(member)?.has('ViewChannel')) throw Error('Contexte de variable inaccessible.');
+    }
+    return next;
+  };
+  const aliases = {...base};
+  for(const [name,value] of Object.entries(base)) if(name.endsWith('_option_id')) aliases['option_'+name.slice(0,-10)]=value;
+  return {
+    base: aliases, definitions, warn, target,
+    read: async (definition, params) => {
+      if (!store) throw Error('Stockage local indisponible.');
+      return store.read(definition.id, await target(definition, params));
+    },
+  };
+}
+export async function runVariableAction(context, args, kind) {
+  const options = context.variableOptions;
+  const config = validateVariableBlock(kind, args, options?.definitions || []);
+  const definition = options.definitions.find(item => item.id === config.variableId);
+  if (!context.variableStore) throw Error('Stockage local des variables indisponible.');
+  const target = await options.target(definition, { user: config.userId, channel: config.channelId, server: config.guildId });
+  const result = await context.variableStore.mutate(definition.id, target, config, kind);
+  if (result?.outside) options.warn('VARIABLE_LINE_OUTSIDE');
+}
+export const VARIABLE_ACTIONS = {
+  setVariable: (context, args) => runVariableAction(context, args, 'setVariable'),
+  deleteVariable: (context, args) => runVariableAction(context, args, 'deleteVariable'),
+};

package/runtime/variable-store-worker.mjs

@@ -0,0 +1,69 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, chmodSync } from 'node:fs';
+import path from 'node:path';
+import { VARIABLE_LIMITS, validateVariableDefinitions, validateVariableBlock, validateVariableValue, emptyVariableValue, variableStorageKey, mutateVariableValue, parseVariableLines } from './custom-variables.mjs';
+
+// This worker never talks to the agent relay. All messages stay inside the bot.
+mkdirSync(path.dirname(workerData.file), { recursive: true, mode: 0o700 });
+const database = new DatabaseSync(workerData.file);
+chmodSync(workerData.file, 0o600);
+database.exec(`PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA max_page_count=${Math.floor(VARIABLE_LIMITS.databaseBytes / 4096)};
+  CREATE TABLE IF NOT EXISTS variable_definitions(id TEXT NOT NULL, schema TEXT NOT NULL, revision INTEGER NOT NULL, default_value TEXT NOT NULL, PRIMARY KEY(id,revision));
+  CREATE TABLE IF NOT EXISTS variable_values(storage_key TEXT PRIMARY KEY, variable_id TEXT NOT NULL, value TEXT NOT NULL);
+  CREATE INDEX IF NOT EXISTS variable_values_definition ON variable_values(variable_id);`);
+let definitions = [];
+function transaction(action) {
+  database.exec('BEGIN IMMEDIATE');
+  try { const result = action(); database.exec('COMMIT'); return result; }
+  catch (error) { database.exec('ROLLBACK'); throw error; }
+}
+function synchronize(raw, deletions) {
+  const next = validateVariableDefinitions(raw);
+  transaction(() => {
+    for (const item of next) {
+      const schema = JSON.stringify([item.type, item.level, item.scope]);
+      const old = database.prepare('SELECT schema FROM variable_definitions WHERE id=? AND revision=?').get(item.id, item.revision);
+      if (old && old.schema !== schema) throw Error('Révision de variable incohérente.');
+      if (!old) {
+        database.prepare('INSERT OR REPLACE INTO variable_definitions VALUES(?,?,?,?)').run(item.id, schema, item.revision, JSON.stringify(emptyVariableValue(item.type)));
+      }
+    }
+    for (const item of deletions || []) if (item?.purge === true && typeof item.id === 'string' && !next.some(definition => definition.id === item.id)) {
+      database.prepare('DELETE FROM variable_values WHERE variable_id=?').run(item.id);
+      database.prepare('DELETE FROM variable_definitions WHERE id=?').run(item.id);
+    }
+  });
+  definitions = next;
+}
+function definition(id) { const result = definitions.find(item => item.id === id); if (!result) throw Error('Variable introuvable.'); return result; }
+function read(item, context) {
+  const row = database.prepare('SELECT value FROM variable_values WHERE storage_key=?').get(variableStorageKey(item, context));
+  const fallback = database.prepare('SELECT default_value FROM variable_definitions WHERE id=? AND revision=?').get(item.id, item.revision);
+  return validateVariableValue(item.type, JSON.parse(row?.value ?? fallback.default_value));
+}
+function mutate(id, context, raw, kind) {
+  const item = definition(id), action = validateVariableBlock(kind, raw, definitions);
+  return transaction(() => {
+    const key = variableStorageKey(item, context);
+    if (kind === 'deleteVariable' && action.operation === 'reset') { database.prepare('DELETE FROM variable_values WHERE storage_key=?').run(key); return { outside: false }; }
+    const current = read(item, context);
+    const outside = kind === 'deleteVariable' && item.type === 'collection' && action.operation === 'lines' && parseVariableLines(action.lines, current.length).outside;
+    const value = validateVariableValue(item.type, mutateVariableValue(item, current, { ...action, kind }));
+    if (!database.prepare('SELECT 1 FROM variable_values WHERE storage_key=?').get(key) && database.prepare('SELECT count(*) AS count FROM variable_values').get().count >= VARIABLE_LIMITS.records) throw Error('Limite de stockage des variables atteinte.');
+    database.prepare('INSERT OR REPLACE INTO variable_values VALUES(?,?,?)').run(key, id, JSON.stringify(value));
+    return { outside: Boolean(outside) }; // No new-value output is exposed to the dashboard.
+  });
+}
+parentPort.on('message', message => {
+  try {
+    let result;
+    if (message.action === 'sync') result = synchronize(message.definitions, message.deletions);
+    else if (message.action === 'read') result = read(definition(message.variableId), message.context);
+    else if (message.action === 'mutate') result = mutate(message.variableId, message.context, message.config, message.kind);
+    else if (message.action === 'close') { database.close(); parentPort.postMessage({ id: message.id, result: true }); parentPort.close(); return; }
+    else throw Error('Opération de variable invalide.');
+    parentPort.postMessage({ id: message.id, result });
+  } catch { parentPort.postMessage({ id: message.id, error: 'Opération de variable refusée. Vérifiez la définition, le type et les limites locales.' }); }
+});
+parentPort.postMessage({ ready: true });

package/runtime/variable-store.mjs

@@ -0,0 +1,26 @@
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+
+export class VariableStore {
+  constructor({ file, definitions = [], deletions = [] }) {
+    if (!path.isAbsolute(file)) throw Error('Le stockage des variables doit utiliser un chemin local absolu.');
+    this.pending = new Map(); this.sequence = 0;
+    // Node 22.5–22.12 requires the flag. It stays confined to this local worker.
+    const execArgv = process.allowedNodeEnvironmentFlags.has('--experimental-sqlite') ? ['--experimental-sqlite'] : [];
+    this.worker = new Worker(new URL('./variable-store-worker.mjs', import.meta.url), { workerData: { file }, execArgv });
+    const initialized = new Promise((resolve, reject) => {
+      this.worker.on('message', message => {
+        if (message.ready) { resolve(); return; }
+        const job = this.pending.get(message.id); if (!job) return;
+        this.pending.delete(message.id); message.error ? job.reject(Error(message.error)) : job.resolve(message.result);
+      });
+      const fail = () => { reject(Error('Le stockage local des variables est indisponible.')); for (const job of this.pending.values()) job.reject(Error('Le stockage local des variables est indisponible.')); this.pending.clear(); };
+      this.worker.on('error', fail); this.worker.on('exit', code => { if (code !== 0) fail(); });
+    });
+    this.ready = initialized.then(() => this.request({ action: 'sync', definitions, deletions }));
+  }
+  request(message) { return new Promise((resolve, reject) => { const id = ++this.sequence; this.pending.set(id, { resolve, reject }); this.worker.postMessage({ ...message, id }); }); }
+  async read(variableId, context) { await this.ready; return this.request({ action: 'read', variableId, context }); }
+  async mutate(variableId, context, config, kind) { await this.ready; return this.request({ action: 'mutate', variableId, context, config, kind }); }
+  async close() { try { await this.ready; await this.request({ action: 'close' }); } finally { await this.worker.terminate(); } }
+}

package/templates/bot.mjs

@@ -1,6 +1,8 @@
+import { fileURLToPath } from 'node:url';
+import { VariableStore } from './runtime/variable-store.mjs';
 import { readFile } from 'node:fs/promises';
 import { Client, GatewayIntentBits, REST, Routes } from 'discord.js';
-import { executeCommand } from './runtime/execute.mjs';
+import { executeCommand, executeButtonInteraction } from './runtime/execute.mjs';
 
 const plan = JSON.parse(await readFile(new URL('./plan.json', import.meta.url), 'utf8'));
 if (plan.schemaVersion !== 1) throw new Error('Version de plan non prise en charge.');
@@ -17,30 +19,39 @@ if (process.argv.includes('--deploy')) {
   await rest.put(route, { body: plan.commands.map(command => ({ name: command.name, description: command.description, type: 1, options: (command.options || []).map(({ type, name, description, required }) => ({ type, name, description, required, ...(type === 3 ? { max_length: 6000 } : {}) })) })) });
   console.log(`${plan.commands.length} commande(s) enregistrée(s).`);
 } else {
+  const variableStore = plan.variableDefinitions?.length || plan.variableDeletions?.length ? new VariableStore({ file: process.env.OFTONE_VARIABLES_PATH || fileURLToPath(new URL('./data/variables.sqlite', import.meta.url)), definitions: plan.variableDefinitions || [], deletions: plan.variableDeletions || [] }) : null;
+  if (variableStore) await variableStore.ready;
+  const variableOptions = { variableStore, variableDefinitions: plan.variableDefinitions || [] };
   const client = new Client({ intents: [GatewayIntentBits.Guilds] });
   const commands = new Map(plan.commands.map(command => [command.name, command]));
   client.once('ready', () => console.log(`Bot connecté : ${client.user.tag}`));
   client.on('interactionCreate', async interaction => {
+    if(interaction.isButton?.()) {
+      try{await executeButtonInteraction(interaction,client,{...variableOptions,onExecution: sample => { if(process.connected&&process.send)try{process.send({type:'usage',hour:Math.floor(Date.now()/3600000)*3600000,...sample},()=>{});}catch{} }});}catch(error){
+        const payload={content:error.code==='BOT_BUSY'?'Le bot est occupé. Réessayez.':'Le bouton n’a pas pu être exécuté. Vérifiez les permissions et la configuration.',embeds:[]};
+        try{if(interaction.deferred&&!interaction.replied)await interaction.editReply(payload);else if(interaction.replied)await interaction.followUp({...payload,flags:64});else await interaction.reply({...payload,flags:64});}catch{console.error('Impossible de notifier le clic.');}
+      }return;
+    }
     if (!interaction.isChatInputCommand()) return;
     const command = commands.get(interaction.commandName);
     if (!command) { await interaction.reply({ content: 'Commande introuvable.', flags: 64 }); return; }
-    const started = performance.now(), hour = Math.floor(Date.now() / 3600000) * 3600000; let success = true;
+    const started = performance.now(), hour = Math.floor(Date.now() / 3600000) * 3600000; let success = true; const warningCodes = new Set();
     try {
-      await executeCommand(command, interaction, client, { onError: () => { success = false; } });
+      await executeCommand(command, interaction, client, { ...variableOptions, onWarning: code => warningCodes.add(code), onError: () => { success = false; } });
     } catch (error) {
       success = false;
       console.error(`Échec de /${command.name} (${error.name}).`);
-      const content = 'La commande n’a pas pu être exécutée. Vérifiez sa configuration et les permissions du bot.';
+      const content = error.code === 'BOT_BUSY' ? 'Le bot est occupé. Réessayez dans quelques instants.' : 'La commande n’a pas pu être exécutée. Vérifiez sa configuration et les permissions du bot.';
       try {
         if (interaction.deferred && !interaction.replied) await interaction.editReply({ content, embeds: [] });
         else if (interaction.replied) await interaction.followUp({ content, flags: 64 });
         else await interaction.reply({ content, flags: 64 });
       } catch { console.error('Impossible de notifier l’utilisateur.'); }
     } finally {
-      if (process.connected && process.send) try { process.send({ type: 'usage', hour, command: command.name, success, durationMs: Math.min(900000, Math.round(performance.now() - started)) }, () => {}); } catch {}
+      if (process.connected && process.send) try { process.send({ type: 'usage', hour, command: command.name, success, warningCodes: [...warningCodes], durationMs: Math.min(900000, Math.round(performance.now() - started)) }, () => {}); } catch {}
     }
   });
   client.on('error', error => console.error(`Erreur du client Discord (${error.name}).`));
-  for (const event of ['SIGTERM', 'SIGINT']) process.on(event, () => { client.destroy(); process.exit(0); });
+  for (const event of ['SIGTERM', 'SIGINT']) process.on(event, async () => { client.destroy(); if (variableStore) await variableStore.close().catch(() => {}); process.exit(0); });
   await client.login(token);
 }

package/update.mjs

@@ -16,10 +16,32 @@ export function validateRelease(release, current, publicKey = RELEASE_PUBLIC_KEY
   const payload = { version: release.version, sha256: release.sha256, bytes: release.bytes };
   if (typeof release.signature !== 'string' || !verify(null, Buffer.from(JSON.stringify(payload)), publicKey, Buffer.from(release.signature, 'base64'))) throw new Error('UPDATE_SIGNATURE');
   const url = new URL(release.url);
-  const local = ['127.0.0.1', 'localhost'].includes(url.hostname) && url.protocol === 'http:';
-  if (!(local || (url.origin === 'https://builder.oftone.fr')) || url.username || url.password || url.search || url.hash || url.pathname !== `/downloads/agent-${release.sha256}.tgz`) throw new Error('UPDATE_ORIGIN');
+  if (url.origin !== 'https://builder.oftone.fr' || url.username || url.password || url.search || url.hash || url.pathname !== `/downloads/agent-${release.sha256}.tgz`) throw new Error('UPDATE_ORIGIN');
   return url;
 }
+export const OFFICIAL_RELEASE_MANIFEST = 'https://builder.oftone.fr/downloads/agent-release.json';
+export async function fetchOfficialRelease(version, currentVersion, { fetchRelease = fetch, publicKey = RELEASE_PUBLIC_KEY } = {}) {
+  if (!newer(version, currentVersion)) throw new Error('UPDATE_INVALID');
+  const response = await fetchRelease(OFFICIAL_RELEASE_MANIFEST, { redirect: 'error', cache: 'no-store', signal: AbortSignal.timeout(15000) });
+  if (!response.ok || Number(response.headers.get('content-length')) > 16384 || !response.body) throw new Error('UPDATE_MANIFEST');
+  const reader = response.body.getReader(), chunks = []; let size = 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read(); if (done) break;
+      size += value.length; if (size > 16384) throw new Error('UPDATE_MANIFEST');
+      chunks.push(Buffer.from(value));
+    }
+  } finally { await reader.cancel().catch(() => {}); }
+  const manifest = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  if (manifest.version !== version || manifest.path !== `/downloads/agent-${manifest.sha256}.tgz`) throw new Error('UPDATE_MANIFEST');
+  const release = { version: manifest.version, sha256: manifest.sha256, bytes: manifest.bytes, signature: manifest.signature, url: 'https://builder.oftone.fr' + manifest.path };
+  validateRelease(release, currentVersion, publicKey);
+  return release;
+}
+export async function installOfficialUpdate(version, options = {}) {
+  const release = await fetchOfficialRelease(version, options.currentVersion, options);
+  return installUpdate(release, options);
+}
 const files = new Set(['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']);
 export function readPackage(archive) {
   const tar = gunzipSync(archive, { maxOutputLength: 8_000_000 });

package/usage.mjs

@@ -1,39 +1,42 @@
-import { readFile, writeFile, rename } from 'node:fs/promises';
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-const HOUR = 3600000;
-export async function createUsageCollector(home, now = () => Date.now()) {
-  const file = path.join(home, 'usage.json');
-  let state;
-  try { state = JSON.parse(await readFile(file, 'utf8')); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-  state ||= { source: randomUUID(), buckets: {}, acknowledged: {} };
-  if (!/^[a-f0-9-]{36}$/.test(state.source) || !state.buckets || !state.acknowledged) throw new Error('Invalid local usage store');
-  let writing = Promise.resolve();
-  return {
-    record(event) {
-      if (event?.type !== 'usage' || !/^[a-z0-9_-]{1,32}$/.test(event.command || '') || typeof event.success !== 'boolean' || !Number.isFinite(event.durationMs) || event.durationMs < 0 || event.durationMs > 900000) return;
-      const current = Math.floor(now() / HOUR) * HOUR;
-      const hour = event.hour ?? current;
-      if (!Number.isSafeInteger(hour) || hour % HOUR || hour > current || hour < current - 719 * HOUR) return;
-      const bucket = state.buckets[hour] ||= { hour, revision: 0, commands: {} };
-      if (!Object.hasOwn(bucket.commands, event.command) && Object.keys(bucket.commands).length >= 200) return;
-      const old = Object.hasOwn(bucket.commands, event.command) ? bucket.commands[event.command] : { count: 0, failed: 0, durationMs: 0 };
-      Object.defineProperty(bucket.commands, event.command, { value: { count: old.count + 1, failed: old.failed + Number(!event.success), durationMs: old.durationMs + Math.round(event.durationMs) }, enumerable: true, writable: true, configurable: true });
-      bucket.revision++;
-    },
-    acknowledge(hour, revision) {
-      if (state.buckets[hour] && Number.isSafeInteger(revision) && revision <= state.buckets[hour].revision) state.acknowledged[hour] = Math.max(state.acknowledged[hour] || 0, revision);
-    },
-    flush(send = () => {}) {
-      writing = writing.catch(() => {}).then(async () => {
-        const cutoff = Math.floor(now() / HOUR) * HOUR - 719 * HOUR;
-        for (const hour of Object.keys(state.buckets)) if (Number(hour) < cutoff) { delete state.buckets[hour]; delete state.acknowledged[hour]; }
-        const snapshot = JSON.stringify(state);
-        await writeFile(file + '.tmp', snapshot, { mode: 0o600 }); await rename(file + '.tmp', file);
-        const saved = JSON.parse(snapshot);
-        for (const bucket of Object.values(saved.buckets).sort((a, b) => b.hour - a.hour).filter(bucket => bucket.revision > (saved.acknowledged[bucket.hour] || 0)).slice(0, 24)) send({ type: 'usage', source: saved.source, ...bucket });
-      });
-      return writing;
-    },
-  };
-}
+import { VARIABLE_WARNING_CODES } from './runtime/custom-variables.mjs';
+import { readFile, writeFile, rename } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+const HOUR = 3600000;
+export async function createUsageCollector(home, now = () => Date.now()) {
+  const file = path.join(home, 'usage.json');
+  let state;
+  try { state = JSON.parse(await readFile(file, 'utf8')); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  state ||= { source: randomUUID(), buckets: {}, acknowledged: {} };
+  if (!/^[a-f0-9-]{36}$/.test(state.source) || !state.buckets || !state.acknowledged) throw new Error('Invalid local usage store');
+  let writing = Promise.resolve();
+  return {
+    record(event) {
+      if (event?.type !== 'usage' || !/^[a-z0-9_-]{1,32}$/.test(event.command || '') || typeof event.success !== 'boolean' || !Number.isFinite(event.durationMs) || event.durationMs < 0 || event.durationMs > 900000) return;
+      const current = Math.floor(now() / HOUR) * HOUR;
+      const hour = event.hour ?? current;
+      if (!Number.isSafeInteger(hour) || hour % HOUR || hour > current || hour < current - 719 * HOUR) return;
+      const bucket = state.buckets[hour] ||= { hour, revision: 0, commands: {} };
+      if (!Object.hasOwn(bucket.commands, event.command) && Object.keys(bucket.commands).length >= 200) return;
+      const old = Object.hasOwn(bucket.commands, event.command) ? bucket.commands[event.command] : { count: 0, failed: 0, durationMs: 0 };
+      const warnings = Object.fromEntries(VARIABLE_WARNING_CODES.filter(code=>Number.isSafeInteger(old.warnings?.[code])&&old.warnings[code]>0).map(code=>[code,old.warnings[code]]));
+      for (const code of new Set(Array.isArray(event.warningCodes) ? event.warningCodes.slice(0,50) : [])) if (VARIABLE_WARNING_CODES.includes(code)) warnings[code] = (warnings[code] || 0) + 1;
+      Object.defineProperty(bucket.commands, event.command, { value: { count: old.count + 1, failed: old.failed + Number(!event.success), durationMs: old.durationMs + Math.round(event.durationMs), ...(Object.keys(warnings).length ? { warnings } : {}) }, enumerable: true, writable: true, configurable: true });
+      bucket.revision++;
+    },
+    acknowledge(hour, revision) {
+      if (state.buckets[hour] && Number.isSafeInteger(revision) && revision <= state.buckets[hour].revision) state.acknowledged[hour] = Math.max(state.acknowledged[hour] || 0, revision);
+    },
+    flush(send = () => {}) {
+      writing = writing.catch(() => {}).then(async () => {
+        const cutoff = Math.floor(now() / HOUR) * HOUR - 719 * HOUR;
+        for (const hour of Object.keys(state.buckets)) if (Number(hour) < cutoff) { delete state.buckets[hour]; delete state.acknowledged[hour]; }
+        const snapshot = JSON.stringify(state);
+        await writeFile(file + '.tmp', snapshot, { mode: 0o600 }); await rename(file + '.tmp', file);
+        const saved = JSON.parse(snapshot);
+        for (const bucket of Object.values(saved.buckets).sort((a, b) => b.hour - a.hour).filter(bucket => bucket.revision > (saved.acknowledged[bucket.hour] || 0)).slice(0, 24)) send({ type: 'usage', source: saved.source, ...bucket });
+      });
+      return writing;
+    },
+  };
+}

package/version.mjs

@@ -1 +1 @@
-export const AGENT_VERSION = '0.5.0';
+export const AGENT_VERSION = '0.5.7';