spiralcord-full 2.1.0

package/src/plugins/manager.js

@@ -0,0 +1,413 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+class SpiralPluginManager extends EventEmitter {
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+    this.plugins = new Map();
+    this.commands = new Map();
+    this.pluginAPIs = new Map();
+    this.pluginConfigs = new Map();
+    this.loadOrder = [];
+    this.maxListeners = 50;
+    this._cache = new Map();
+  }
+
+  async loadPlugins(pluginsDir) {
+    try {
+      await fs.access(pluginsDir);
+    } catch {
+      return;
+    }
+
+    const pluginFolders = await fs.readdir(pluginsDir);
+    const manifests = [];
+
+    const manifestPromises = pluginFolders.map(async (folder) => {
+      const pluginPath = path.resolve(pluginsDir, folder);
+      const manifestPath = path.join(pluginPath, 'plugin.json');
+      try {
+        await fs.access(manifestPath);
+        const data = await fs.readFile(manifestPath, 'utf-8');
+        return { folder, pluginPath, manifest: JSON.parse(data) };
+      } catch {
+        return null;
+      }
+    });
+
+    const results = await Promise.all(manifestPromises);
+    for (const r of results) {
+      if (r) manifests.push(r);
+    }
+
+    const sorted = this.resolveDependencies(manifests);
+
+    const loadPromises = sorted.map(({ folder, pluginPath, manifest }) =>
+      this.loadPlugin(folder, pluginPath, manifest)
+    );
+    await Promise.all(loadPromises);
+  }
+
+  resolveDependencies(manifests) {
+    const manifestMap = new Map();
+    for (const m of manifests) {
+      manifestMap.set(m.manifest.name, m);
+    }
+
+    const resolved = [];
+    const visited = new Set();
+    const visiting = new Set();
+
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        console.error(`[manager] Circular dependency: ${name}`);
+        return;
+      }
+      visiting.add(name);
+
+      const m = manifestMap.get(name);
+      if (m && m.manifest.dependencies) {
+        for (const dep of Object.keys(m.manifest.dependencies)) {
+          visit(dep);
+        }
+      }
+
+      visiting.delete(name);
+      visited.add(name);
+      if (m) resolved.push(m);
+    };
+
+    for (const m of manifests) {
+      visit(m.manifest.name);
+    }
+
+    return resolved;
+  }
+
+  async loadPlugin(folder, pluginPath, manifest) {
+    const indexPath = path.join(pluginPath, 'index.js');
+    const dslPath = path.join(pluginPath, 'plugin.dsl');
+    const configSchemaPath = path.join(pluginPath, 'config.schema.json');
+    const configPath = path.join(pluginPath, 'config.json');
+
+    const [config, pluginModule] = await Promise.all([
+      this.loadPluginConfig(configSchemaPath, configPath),
+      this._loadModule(indexPath, dslPath, manifest)
+    ]);
+
+    if (!pluginModule) return;
+
+    this.pluginConfigs.set(manifest.name, config);
+    this.plugins.set(manifest.name, { manifest, module: pluginModule, path: pluginPath });
+
+    if (pluginModule.init) {
+      await pluginModule.init(config, this.runtime);
+    }
+
+    if (pluginModule.commands) {
+      for (const [name, cmd] of Object.entries(pluginModule.commands)) {
+        this.registerCommand(manifest.name, name, cmd);
+      }
+    }
+
+    if (pluginModule.keywords) {
+      for (const [kw, handler] of Object.entries(pluginModule.keywords)) {
+        this.registerCommand(manifest.name, kw, { execute: handler, isKeyword: true });
+      }
+    }
+
+    if (pluginModule.hooks) {
+      for (const [hookName, handler] of Object.entries(pluginModule.hooks)) {
+        this.on(hookName, async (payload) => {
+          try {
+            await handler(payload, this.runtime);
+          } catch (error) {
+            console.error(`[manager] Hook error ${hookName} from ${manifest.name}:`, error.message);
+          }
+        });
+      }
+    }
+
+    if (pluginModule.api) {
+      this.pluginAPIs.set(manifest.name, pluginModule.api);
+    }
+
+    this.loadOrder.push(manifest.name);
+    console.log(`[manager] Loaded ${manifest.name} v${manifest.version}`);
+  }
+
+  async _loadModule(indexPath, dslPath, manifest) {
+    try {
+      await fs.access(indexPath);
+      delete require.cache[require.resolve(indexPath)];
+      return require(indexPath);
+    } catch {}
+
+    try {
+      await fs.access(dslPath);
+      const dslContent = await fs.readFile(dslPath, 'utf-8');
+      return this.compileDSL(dslContent, manifest);
+    } catch {}
+
+    return null;
+  }
+
+  registerCommand(pluginName, name, cmd) {
+    if (!this.commands.has(name)) {
+      this.commands.set(name, []);
+    }
+
+    const registrations = this.commands.get(name);
+    const existing = registrations.find(r => r.plugin === pluginName);
+
+    if (existing) {
+      existing.handler = cmd.execute || cmd;
+      existing.description = cmd.description || existing.description;
+      return;
+    }
+
+    const manifest = this.plugins.get(pluginName)?.manifest;
+    const collisionPolicy = manifest?.collision_policy || 'last-wins';
+
+    if (registrations.length > 0) {
+      const conflict = registrations[0];
+      console.warn(`[manager] Command "${name}" collision: ${conflict.plugin} vs ${pluginName}`);
+
+      if (collisionPolicy === 'error') {
+        console.error(`[manager] Refusing ${pluginName}: "${name}" already registered`);
+        return;
+      }
+    }
+
+    registrations.push({
+      plugin: pluginName,
+      handler: cmd.execute || cmd,
+      description: cmd.description || '',
+      usage: cmd.usage || '',
+      slash: cmd.slash || false,
+      priority: cmd.priority || 0
+    });
+
+    registrations.sort((a, b) => b.priority - a.priority);
+  }
+
+  getCommand(name) {
+    const registrations = this.commands.get(name);
+    if (!registrations || registrations.length === 0) return null;
+    return registrations[0];
+  }
+
+  getAllCommands() {
+    const result = new Map();
+    for (const [name, registrations] of this.commands) {
+      if (registrations.length > 0) {
+        result.set(name, registrations[0]);
+      }
+    }
+    return result;
+  }
+
+  getSlashCommands() {
+    const result = [];
+    for (const [name, registrations] of this.commands) {
+      const cmd = registrations[0];
+      if (cmd && cmd.slash) {
+        result.push({ name, description: cmd.description });
+      }
+    }
+    return result;
+  }
+
+  async executeCommand(name, message, args) {
+    const cmd = this.getCommand(name);
+    if (!cmd) return false;
+
+    const config = this.runtime.config;
+    const disabledCommands = config.disabledCommands || [];
+    if (disabledCommands.includes(name)) {
+      await message.reply(`Command \`${name}\` has been disabled.`);
+      return true;
+    }
+
+    try {
+      await cmd.handler(message, args, this.runtime);
+      return true;
+    } catch (error) {
+      console.error(`[manager] Error executing ${name}:`, error);
+      await message.reply('An error occurred while executing this command.');
+      return true;
+    }
+  }
+
+  async emitHook(eventName, payload) {
+    this.emit(eventName, payload);
+  }
+
+  async emitHookSerial(eventName, payload) {
+    const listeners = this.listeners(eventName);
+    for (const listener of listeners) {
+      await listener(payload);
+    }
+  }
+
+  async emitHookWithResult(eventName, payload) {
+    const listeners = this.listeners(eventName);
+    for (const listener of listeners) {
+      const result = await listener(payload);
+      if (result === true) return true;
+    }
+    return false;
+  }
+
+  async loadPluginConfig(schemaPath, configPath) {
+    let config = {};
+
+    try {
+      const schemaData = await fs.readFile(schemaPath, 'utf-8');
+      config = this.extractDefaults(JSON.parse(schemaData));
+    } catch {}
+
+    try {
+      const configData = await fs.readFile(configPath, 'utf-8');
+      config = { ...config, ...JSON.parse(configData) };
+    } catch {}
+
+    return config;
+  }
+
+  extractDefaults(schema) {
+    const defaults = {};
+    if (!schema.properties) return defaults;
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (prop.default !== undefined) defaults[key] = prop.default;
+    }
+    return defaults;
+  }
+
+  getPluginConfig(pluginName) {
+    return this.pluginConfigs.get(pluginName) || {};
+  }
+
+  getPluginAPI(pluginName) {
+    return this.pluginAPIs.get(pluginName) || null;
+  }
+
+  getPlugins() {
+    return Array.from(this.plugins.keys());
+  }
+
+  getPluginInfo(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return null;
+    return {
+      manifest: plugin.manifest,
+      path: plugin.path,
+      config: this.pluginConfigs.get(pluginName)
+    };
+  }
+
+  compileDSL(dslContent, manifest) {
+    const lines = dslContent.split('\n');
+    const commands = {};
+
+    let currentBlock = null;
+    let blockLines = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === '' || trimmed.startsWith('#')) continue;
+
+      if (trimmed.startsWith('COMMAND ')) {
+        if (currentBlock) {
+          this._processDSLBlock(currentBlock, blockLines, commands);
+          blockLines = [];
+        }
+        const match = trimmed.match(/COMMAND\s+(\S+)\s+"([^"]+)"/);
+        if (match) {
+          currentBlock = { type: 'command', name: match[1], description: match[2], aliases: [], cooldown: 0, requiresArgs: null, requiresPermission: null, response: null, responsePool: null, embed: null };
+        }
+        continue;
+      }
+
+      if (trimmed === 'END') {
+        if (currentBlock) {
+          this._processDSLBlock(currentBlock, blockLines, commands);
+          currentBlock = null;
+          blockLines = [];
+        }
+        continue;
+      }
+
+      if (currentBlock) blockLines.push(trimmed);
+    }
+
+    return { commands, init: async (config, runtime) => {} };
+  }
+
+  _processDSLBlock(block, lines, commands) {
+    if (block.type !== 'command') return;
+
+    for (const line of lines) {
+      if (line.startsWith('ALIASES ')) block.aliases = line.slice(8).split(',').map(a => a.trim());
+      else if (line.startsWith('COOLDOWN ')) block.cooldown = parseInt(line.slice(9)) * 1000;
+      else if (line.startsWith('REQUIRES_ARGS ')) block.requiresArgs = line.slice(14).replace(/^["']|["']$/g, '');
+      else if (line.startsWith('REQUIRES_PERMISSION ')) block.requiresPermission = line.slice(20);
+      else if (line.startsWith('RESPONSE ')) block.response = line.slice(9).replace(/^["']|["']$/g, '');
+      else if (line.startsWith('RESPONSE_POOL')) block.responsePool = [];
+      else if (line.startsWith('EMBED ')) {
+        const match = line.match(/EMBED\s+"([^"]+)"/);
+        block.embed = { color: match?.[1] || '#00FF00' };
+      }
+      else if (line.startsWith('TITLE ')) { if (block.embed) block.embed.title = line.slice(6).replace(/^["']|["']$/g, ''); }
+      else if (line.startsWith('DESCRIPTION ')) { if (block.embed) block.embed.description = line.slice(12).replace(/^["']|["']$/g, ''); }
+      else if (block.responsePool !== null && !line.startsWith('TITLE') && !line.startsWith('DESCRIPTION')) {
+        block.responsePool.push(line.replace(/^["']|["']$/g, ''));
+      }
+    }
+
+    const blockRef = block;
+    const manager = this;
+    const handler = async (message, args, runtime) => {
+      if (blockRef.requiresArgs && (!args || args.length === 0)) return message.reply(blockRef.requiresArgs);
+      if (blockRef.requiresPermission && !message.member?.permissions.has(blockRef.requiresPermission)) {
+        return message.reply(`You need \`${blockRef.requiresPermission}\` permission.`);
+      }
+
+      const ctxMap = new Map([
+        ['user.id', message.author.id], ['user.name', message.author.username],
+        ['channel.id', message.channel.id], ['guild.id', message.guild?.id || 'dm'],
+        ['guild.name', message.guild?.name || 'DM'], ['args', args.join(' ')]
+      ]);
+
+      if (blockRef.response) return message.reply(manager._resolveDSLVars(blockRef.response, ctxMap));
+      if (blockRef.responsePool && blockRef.responsePool.length > 0) {
+        const response = blockRef.responsePool[Math.floor(Math.random() * blockRef.responsePool.length)];
+        return message.reply(manager._resolveDSLVars(response, ctxMap));
+      }
+      if (blockRef.embed) {
+        const { EmbedBuilder } = require('discord.js');
+        const embed = new EmbedBuilder()
+          .setColor(manager._resolveDSLVars(blockRef.embed.color, ctxMap))
+          .setTitle(manager._resolveDSLVars(blockRef.embed.title || '', ctxMap))
+          .setDescription(manager._resolveDSLVars(blockRef.embed.description || '', ctxMap));
+        return message.reply({ embeds: [embed] });
+      }
+    };
+
+    commands[blockRef.name] = { description: blockRef.description, execute: handler, slash: false };
+    for (const alias of blockRef.aliases) {
+      commands[alias] = { description: blockRef.description, execute: handler, slash: false };
+    }
+  }
+
+  _resolveDSLVars(text, ctxMap) {
+    if (!text) return '';
+    return text.replace(/\{(\w+)\}/g, (match, key) => ctxMap.has(key) ? ctxMap.get(key) : match);
+  }
+}
+
+module.exports = SpiralPluginManager;

package/src/runtime.js

@@ -0,0 +1,180 @@
+const { Client, GatewayIntentBits, Events } = require('discord.js');
+const fs = require('fs');
+const path = require('path');
+const SpiralPluginManager = require('./plugins/manager');
+
+class SpiralRuntime {
+  constructor(config) {
+    this.config = config || {};
+    this.client = null;
+    this.pluginManager = new SpiralPluginManager(this);
+    this.startTime = Date.now();
+    this._pluginsDir = path.join(process.cwd(), 'plugins');
+  }
+
+  async start() {
+    const t0 = Date.now();
+    console.log('[runtime] Starting Spiralcord v' + require('../package.json').version);
+
+    this.client = new Client({ intents: this._resolveIntents() });
+    this._bindEvents();
+
+    console.log('[runtime] Loading plugins...');
+    await this.pluginManager.loadPlugins(this._pluginsDir);
+
+    const pluginCount = this.pluginManager.getPlugins().length;
+    const commandCount = this.pluginManager.getAllCommands().size;
+    console.log(`[runtime] ${pluginCount} plugins, ${commandCount} commands loaded in ${Date.now() - t0}ms`);
+
+    await this.client.login(this.config.token);
+  }
+
+  _resolveIntents() {
+    const intents = this.config.intents || ['Guilds', 'GuildMessages', 'MessageContent'];
+    return intents.map(i => {
+      const map = {
+        'Guilds': GatewayIntentBits.Guilds,
+        'GuildMessages': GatewayIntentBits.GuildMessages,
+        'MessageContent': GatewayIntentBits.MessageContent,
+        'GuildMembers': GatewayIntentBits.GuildMembers,
+        'GuildVoiceStates': GatewayIntentBits.GuildVoiceStates,
+        'DirectMessages': GatewayIntentBits.DirectMessages,
+        'GuildPresences': GatewayIntentBits.GuildPresences
+      };
+      return map[i] || GatewayIntentBits.Guilds;
+    });
+  }
+
+  _bindEvents() {
+    this.client.removeAllListeners();
+
+    this.client.on(Events.ClientReady, async () => {
+      console.log(`[runtime] Ready as ${this.client.user.tag} | ${this.client.guilds.cache.size} servers | ${this.client.users.cache.size} users`);
+
+      await this.pluginManager.emitHook('bot_ready', {
+        client: this.client,
+        user: this.client.user,
+        config: this.config
+      });
+    });
+
+    this.client.on(Events.MessageCreate, async (message) => {
+      if (message.author.bot) return;
+      await this.pluginManager.emitHook('message_received', {
+        message,
+        user: message.author,
+        guild: message.guild,
+        channel: message.channel
+      });
+    });
+
+    this.client.on(Events.InteractionCreate, async (interaction) => {
+      await this.pluginManager.emitHook('interaction_received', {
+        interaction,
+        user: interaction.user,
+        guild: interaction.guild,
+        channel: interaction.channel
+      });
+    });
+
+    this.client.on(Events.PresenceUpdate, async (oldPresence, newPresence) => {
+      await this.pluginManager.emitHook('presence_update', {
+        oldPresence,
+        newPresence,
+        user: newPresence.user,
+        guild: newPresence.guild
+      });
+    });
+
+    this.client.on(Events.GuildCreate, async (guild) => {
+      console.log(`[runtime] Joined: ${guild.name}`);
+      await this.pluginManager.emitHook('guild_joined', { guild });
+    });
+
+    this.client.on(Events.GuildDelete, async (guild) => {
+      console.log(`[runtime] Left: ${guild.name}`);
+      await this.pluginManager.emitHook('guild_left', { guild });
+    });
+
+    this.client.on(Events.VoiceStateUpdate, async (oldState, newState) => {
+      await this.pluginManager.emitHook('voice_state_update', {
+        oldState,
+        newState,
+        user: newState.member?.user,
+        guild: newState.guild
+      });
+    });
+
+    this.client.on(Events.MessageReactionAdd, async (reaction, user) => {
+      await this.pluginManager.emitHook('reaction_add', {
+        reaction,
+        user,
+        message: reaction.message
+      });
+    });
+
+    this.client.on(Events.MessageReactionRemove, async (reaction, user) => {
+      await this.pluginManager.emitHook('reaction_remove', {
+        reaction,
+        user,
+        message: reaction.message
+      });
+    });
+
+    this.client.on(Events.Error, (error) => {
+      console.error('[runtime] Error:', error.message);
+    });
+
+    process.on('unhandledRejection', (error) => {
+      console.error('[runtime] Unhandled:', error);
+    });
+  }
+
+  async restart() {
+    const t0 = Date.now();
+    console.log('[runtime] Restarting...');
+
+    await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+
+    this.client.destroy();
+    this.client.removeAllListeners();
+
+    this.client = new Client({ intents: this._resolveIntents() });
+    this._bindEvents();
+
+    await this.client.login(this.config.token);
+
+    console.log(`[runtime] Restarted in ${Date.now() - t0}ms`);
+  }
+
+  async stop() {
+    console.log('[runtime] Shutting down...');
+    await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+    if (this.client) {
+      this.client.destroy();
+    }
+    process.exit(0);
+  }
+
+  getUptime() {
+    return Date.now() - this.startTime;
+  }
+
+  getCommand(name) {
+    return this.pluginManager.getCommand(name);
+  }
+
+  getAllCommands() {
+    return this.pluginManager.getAllCommands();
+  }
+
+  getPluginConfig(pluginName) {
+    return this.pluginManager.getPluginConfig(pluginName);
+  }
+
+  getPluginAPI(pluginName) {
+    return this.pluginManager.getPluginAPI(pluginName);
+  }
+}
+
+module.exports = SpiralRuntime;