spiralcord-full 2.1.0 → 2.3.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "spiralcord-full",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Spiralcord Full - Discord Bot Runtime with Voice, Music, AI, Database & Image Support",
   "main": "src/index.js",
+  "types": "src/types/index.d.ts",
   "bin": {
     "spiral": "./bin/spiral.js"
   },
@@ -43,7 +44,8 @@
     "dotenv": "^16.3.0",
     "chalk": "^4.1.2",
     "ms": "^2.1.3",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "chokidar": "^3.6.0"
   },
   "engines": {
     "node": ">=16.0.0"

package/src/plugins/manager.js

@@ -2,6 +2,7 @@ const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
 const EventEmitter = require('events');
+const { EmbedBuilder } = require('discord.js');
 
 class SpiralPluginManager extends EventEmitter {
   constructor(runtime) {
@@ -14,6 +15,7 @@ class SpiralPluginManager extends EventEmitter {
     this.loadOrder = [];
     this.maxListeners = 50;
     this._cache = new Map();
+    this._hookCleanups = [];
   }
 
   async loadPlugins(pluginsDir) {
@@ -23,14 +25,18 @@ class SpiralPluginManager extends EventEmitter {
       return;
     }
 
-    const pluginFolders = await fs.readdir(pluginsDir);
+    this.removeAllListeners();
+    this._hookCleanups.forEach(cleanup => cleanup());
+    this._hookCleanups = [];
+
+    const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+    const pluginFolders = entries.filter(e => e.isDirectory()).map(e => e.name);
     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 {
@@ -45,10 +51,13 @@ class SpiralPluginManager extends EventEmitter {
 
     const sorted = this.resolveDependencies(manifests);
 
-    const loadPromises = sorted.map(({ folder, pluginPath, manifest }) =>
-      this.loadPlugin(folder, pluginPath, manifest)
-    );
-    await Promise.all(loadPromises);
+    for (const { folder, pluginPath, manifest } of sorted) {
+      try {
+        await this.loadPlugin(folder, pluginPath, manifest);
+      } catch (error) {
+        console.error(`[manager] Failed to load ${manifest.name}:`, error.message);
+      }
+    }
   }
 
   resolveDependencies(manifests) {
@@ -64,7 +73,7 @@ class SpiralPluginManager extends EventEmitter {
     const visit = (name) => {
       if (visited.has(name)) return;
       if (visiting.has(name)) {
-        console.error(`[manager] Circular dependency: ${name}`);
+        console.error(`[manager] Circular dependency detected: ${name}`);
         return;
       }
       visiting.add(name);
@@ -72,6 +81,9 @@ class SpiralPluginManager extends EventEmitter {
       const m = manifestMap.get(name);
       if (m && m.manifest.dependencies) {
         for (const dep of Object.keys(m.manifest.dependencies)) {
+          if (!manifestMap.has(dep)) {
+            console.warn(`[manager] Missing dependency "${dep}" for ${name}`);
+          }
           visit(dep);
         }
       }
@@ -104,8 +116,12 @@ class SpiralPluginManager extends EventEmitter {
     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);
+    try {
+      if (pluginModule.init) {
+        await pluginModule.init(config, this.runtime);
+      }
+    } catch (error) {
+      console.error(`[manager] Init failed for ${manifest.name}:`, error.message);
     }
 
     if (pluginModule.commands) {
@@ -122,13 +138,15 @@ class SpiralPluginManager extends EventEmitter {
 
     if (pluginModule.hooks) {
       for (const [hookName, handler] of Object.entries(pluginModule.hooks)) {
-        this.on(hookName, async (payload) => {
+        const listener = async (payload) => {
           try {
             await handler(payload, this.runtime);
           } catch (error) {
             console.error(`[manager] Hook error ${hookName} from ${manifest.name}:`, error.message);
           }
-        });
+        };
+        this.on(hookName, listener);
+        this._hookCleanups.push(() => this.removeListener(hookName, listener));
       }
     }
 
@@ -143,15 +161,24 @@ class SpiralPluginManager extends EventEmitter {
   async _loadModule(indexPath, dslPath, manifest) {
     try {
       await fs.access(indexPath);
-      delete require.cache[require.resolve(indexPath)];
+      const resolved = require.resolve(indexPath);
+      delete require.cache[resolved];
       return require(indexPath);
-    } catch {}
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error(`[manager] Failed to load ${indexPath}:`, error.message);
+      }
+    }
 
     try {
       await fs.access(dslPath);
       const dslContent = await fs.readFile(dslPath, 'utf-8');
       return this.compileDSL(dslContent, manifest);
-    } catch {}
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error(`[manager] Failed to load ${dslPath}:`, error.message);
+      }
+    }
 
     return null;
   }
@@ -167,20 +194,26 @@ class SpiralPluginManager extends EventEmitter {
     if (existing) {
       existing.handler = cmd.execute || cmd;
       existing.description = cmd.description || existing.description;
+      registrations.sort((a, b) => b.priority - a.priority);
       return;
     }
 
-    const manifest = this.plugins.get(pluginName)?.manifest;
-    const collisionPolicy = manifest?.collision_policy || 'last-wins';
-
     if (registrations.length > 0) {
       const conflict = registrations[0];
+      const conflictManifest = this.plugins.get(conflict.plugin)?.manifest;
+      const policy = conflictManifest?.collision_policy || 'last-wins';
+
       console.warn(`[manager] Command "${name}" collision: ${conflict.plugin} vs ${pluginName}`);
 
-      if (collisionPolicy === 'error') {
+      if (policy === 'error') {
         console.error(`[manager] Refusing ${pluginName}: "${name}" already registered`);
         return;
       }
+
+      if (policy === 'first-wins') {
+        console.log(`[manager] Keeping ${conflict.plugin}'s "${name}" (first-wins)`);
+        return;
+      }
     }
 
     registrations.push({
@@ -222,6 +255,21 @@ class SpiralPluginManager extends EventEmitter {
     return result;
   }
 
+  getReplCommands() {
+    const result = {};
+    for (const [pluginName, { module: mod }] of this.plugins) {
+      if (mod.repl) {
+        for (const [cmdName, cmd] of Object.entries(mod.repl)) {
+          result[cmdName] = {
+            ...cmd,
+            plugin: pluginName
+          };
+        }
+      }
+    }
+    return result;
+  }
+
   async executeCommand(name, message, args) {
     const cmd = this.getCommand(name);
     if (!cmd) return false;
@@ -234,7 +282,7 @@ class SpiralPluginManager extends EventEmitter {
     }
 
     try {
-      await cmd.handler(message, args, this.runtime);
+      await cmd.handler(message, args || [], this.runtime);
       return true;
     } catch (error) {
       console.error(`[manager] Error executing ${name}:`, error);
@@ -244,7 +292,14 @@ class SpiralPluginManager extends EventEmitter {
   }
 
   async emitHook(eventName, payload) {
-    this.emit(eventName, payload);
+    const listeners = this.listeners(eventName);
+    for (const listener of listeners) {
+      try {
+        await listener(payload);
+      } catch (error) {
+        console.error(`[manager] Hook error ${eventName}:`, error.message);
+      }
+    }
   }
 
   async emitHookSerial(eventName, payload) {
@@ -313,6 +368,7 @@ class SpiralPluginManager extends EventEmitter {
   compileDSL(dslContent, manifest) {
     const lines = dslContent.split('\n');
     const commands = {};
+    const slashCommands = [];
 
     let currentBlock = null;
     let blockLines = [];
@@ -321,21 +377,30 @@ class SpiralPluginManager extends EventEmitter {
       const trimmed = line.trim();
       if (trimmed === '' || trimmed.startsWith('#')) continue;
 
-      if (trimmed.startsWith('COMMAND ')) {
+      if (trimmed.startsWith('COMMAND ') || trimmed.startsWith('SLASH_COMMAND ')) {
         if (currentBlock) {
-          this._processDSLBlock(currentBlock, blockLines, commands);
+          this._processDSLBlock(currentBlock, blockLines, commands, slashCommands);
           blockLines = [];
         }
-        const match = trimmed.match(/COMMAND\s+(\S+)\s+"([^"]+)"/);
+        const isSlash = trimmed.startsWith('SLASH_COMMAND ');
+        const pattern = isSlash ? /SLASH_COMMAND\s+(\S+)\s+"([^"]+)"/ : /COMMAND\s+(\S+)\s+"([^"]+)"/;
+        const match = trimmed.match(pattern);
         if (match) {
-          currentBlock = { type: 'command', name: match[1], description: match[2], aliases: [], cooldown: 0, requiresArgs: null, requiresPermission: null, response: null, responsePool: null, embed: null };
+          currentBlock = {
+            type: 'command', name: match[1], description: match[2],
+            aliases: [], cooldown: 0, requiresArgs: null, requiresPermission: null,
+            response: null, responsePool: null, embed: null, slash: isSlash,
+            buttons: [], selects: [], dbOps: [], selectPlaceholder: null
+          };
+        } else {
+          currentBlock = null;
         }
         continue;
       }
 
       if (trimmed === 'END') {
         if (currentBlock) {
-          this._processDSLBlock(currentBlock, blockLines, commands);
+          this._processDSLBlock(currentBlock, blockLines, commands, slashCommands);
           currentBlock = null;
           blockLines = [];
         }
@@ -345,15 +410,30 @@ class SpiralPluginManager extends EventEmitter {
       if (currentBlock) blockLines.push(trimmed);
     }
 
-    return { commands, init: async (config, runtime) => {} };
+    const init = async (config, runtime) => {};
+
+    if (slashCommands.length > 0) {
+      init._slashCommands = slashCommands;
+    }
+
+    return { commands, init };
   }
 
-  _processDSLBlock(block, lines, commands) {
+  _processDSLBlock(block, lines, commands, slashCommands) {
     if (block.type !== 'command') return;
 
+    const dslKeywords = [
+      'ALIASES', 'COOLDOWN', 'REQUIRES_ARGS', 'REQUIRES_PERMISSION',
+      'RESPONSE', 'RESPONSE_POOL', 'EMBED', 'TITLE', 'DESCRIPTION',
+      'BUTTON', 'SELECT', 'DB_SET', 'DB_GET', 'DB_ADD', 'DB_DELETE', 'DB_RESPONSE'
+    ];
+
     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('COOLDOWN ')) {
+        const val = parseInt(line.slice(9), 10);
+        block.cooldown = isNaN(val) ? 0 : val * 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, '');
@@ -364,7 +444,41 @@ class SpiralPluginManager extends EventEmitter {
       }
       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')) {
+      else if (line.startsWith('BUTTON ')) {
+        const bMatch = line.match(/BUTTON\s+"([^"]+)"\s+STYLE\s+(\w+)\s+ACTION\s+(\S+)/);
+        if (bMatch) block.buttons.push({ label: bMatch[1], style: bMatch[2], action: bMatch[3] });
+      }
+      else if (line.startsWith('SELECT ')) {
+        const sMatch = line.match(/SELECT\s+"([^"]+)"\s+OPTION\s+"([^"]+)"\s+VALUE\s+"([^"]+)"/);
+        if (sMatch) {
+          if (!block.selectPlaceholder) block.selectPlaceholder = sMatch[1];
+          block.selects.push({ label: sMatch[2], value: sMatch[3] });
+        } else {
+          const sPlaceholder = line.match(/SELECT\s+"([^"]+)"/);
+          if (sPlaceholder) block.selectPlaceholder = sPlaceholder[1];
+        }
+      }
+      else if (line.startsWith('DB_SET ')) {
+        const dbMatch = line.match(/DB_SET\s+(\S+)\s+(.+)/);
+        if (dbMatch) block.dbOps.push({ op: 'set', key: dbMatch[1], value: dbMatch[2].replace(/^["']|["']$/g, '') });
+      }
+      else if (line.startsWith('DB_GET ')) {
+        const dbMatch = line.match(/DB_GET\s+(\S+)/);
+        if (dbMatch) block.dbOps.push({ op: 'get', key: dbMatch[1] });
+      }
+      else if (line.startsWith('DB_ADD ')) {
+        const dbMatch = line.match(/DB_ADD\s+(\S+)\s+(-?\d+)/);
+        if (dbMatch) block.dbOps.push({ op: 'add', key: dbMatch[1], amount: parseInt(dbMatch[2], 10) });
+      }
+      else if (line.startsWith('DB_DELETE ')) {
+        const dbMatch = line.match(/DB_DELETE\s+(\S+)/);
+        if (dbMatch) block.dbOps.push({ op: 'delete', key: dbMatch[1] });
+      }
+      else if (line.startsWith('DB_RESPONSE ')) {
+        const dbMatch = line.match(/DB_RESPONSE\s+"([^"]+)"/);
+        if (dbMatch) block.dbOps.push({ op: 'response', key: dbMatch[1] });
+      }
+      else if (block.responsePool !== null && !dslKeywords.some(kw => line.startsWith(kw))) {
         block.responsePool.push(line.replace(/^["']|["']$/g, ''));
       }
     }
@@ -373,23 +487,45 @@ class SpiralPluginManager extends EventEmitter {
     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)) {
+      if (blockRef.requiresPermission && message.member && !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(' ')]
+        ['guild.name', message.guild?.name || 'DM'], ['args', (args || []).join(' ')]
       ]);
 
+      for (const dbOp of blockRef.dbOps) {
+        const key = manager._resolveDSLVars(dbOp.key, ctxMap);
+        const userId = message.author.id;
+        const fullKey = `${userId}.${key}`;
+
+        if (dbOp.op === 'set') {
+          const val = manager._resolveDSLVars(dbOp.value, ctxMap);
+          const num = parseFloat(val);
+          runtime.db.set(fullKey, isNaN(num) ? val : num);
+        } else if (dbOp.op === 'get') {
+          const val = runtime.db.get(fullKey);
+          ctxMap.set('db_value', val !== null ? String(val) : '0');
+        } else if (dbOp.op === 'add') {
+          const newVal = runtime.db.add(fullKey, dbOp.amount);
+          ctxMap.set('db_value', String(newVal));
+        } else if (dbOp.op === 'delete') {
+          runtime.db.delete(fullKey);
+        } else if (dbOp.op === 'response') {
+          const val = runtime.db.get(fullKey);
+          ctxMap.set('db_response', val !== null ? String(val) : '0');
+        }
+      }
+
       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))
@@ -398,10 +534,17 @@ class SpiralPluginManager extends EventEmitter {
       }
     };
 
-    commands[blockRef.name] = { description: blockRef.description, execute: handler, slash: false };
+    commands[blockRef.name] = {
+      description: blockRef.description, execute: handler,
+      slash: blockRef.slash || false
+    };
     for (const alias of blockRef.aliases) {
       commands[alias] = { description: blockRef.description, execute: handler, slash: false };
     }
+
+    if (blockRef.slash) {
+      slashCommands.push({ name: blockRef.name, description: blockRef.description });
+    }
   }
 
   _resolveDSLVars(text, ctxMap) {
@@ -410,4 +553,4 @@ class SpiralPluginManager extends EventEmitter {
   }
 }
 
-module.exports = SpiralPluginManager;
+module.exports = SpiralPluginManager;

package/src/runtime.js

@@ -3,13 +3,117 @@ const fs = require('fs');
 const path = require('path');
 const SpiralPluginManager = require('./plugins/manager');
 
+class SpiralDB {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.data = {};
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        this.data = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+      }
+    } catch { this.data = {}; }
+  }
+
+  _save() {
+    try {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+    } catch (e) {
+      console.error('[db] Save error:', e.message);
+    }
+  }
+
+  get(key, defaultValue = null) {
+    if (key == null || typeof key !== 'string') return defaultValue;
+    const keys = key.split('.');
+    let val = this.data;
+    for (const k of keys) {
+      if (val === null || val === undefined || typeof val !== 'object') return defaultValue;
+      val = val[k];
+    }
+    return val !== undefined ? val : defaultValue;
+  }
+
+  set(key, value) {
+    if (key == null || typeof key !== 'string') return value;
+    const keys = key.split('.');
+    let obj = this.data;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (obj[keys[i]] !== undefined && typeof obj[keys[i]] !== 'object') {
+        console.warn(`[db] Overwriting non-object at key "${keys.slice(0, i + 1).join('.')}"`);
+      }
+      if (!obj[keys[i]] || typeof obj[keys[i]] !== 'object') obj[keys[i]] = {};
+      obj = obj[keys[i]];
+    }
+    obj[keys[keys.length - 1]] = value;
+    this._save();
+    return value;
+  }
+
+  add(key, amount) {
+    if (typeof amount !== 'number' || isNaN(amount)) {
+      console.warn(`[db] add() received non-numeric amount: ${amount}`);
+      amount = 0;
+    }
+    const current = this.get(key, 0);
+    const newVal = (typeof current === 'number' ? current : 0) + amount;
+    this.set(key, newVal);
+    return newVal;
+  }
+
+  delete(key) {
+    if (key == null || typeof key !== 'string') return false;
+    const keys = key.split('.');
+    let obj = this.data;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!obj[keys[i]] || typeof obj[keys[i]] !== 'object') return false;
+      obj = obj[keys[i]];
+    }
+    const existed = keys[keys.length - 1] in obj;
+    delete obj[keys[keys.length - 1]];
+    this._save();
+    return existed;
+  }
+
+  has(key) {
+    if (key == null || typeof key !== 'string') return false;
+    const keys = key.split('.');
+    let val = this.data;
+    for (const k of keys) {
+      if (val === null || val === undefined || typeof val !== 'object') return false;
+      if (!(k in val)) return false;
+      val = val[k];
+    }
+    return true;
+  }
+
+  all() {
+    return { ...this.data };
+  }
+
+  clear() {
+    this.data = {};
+    this._save();
+  }
+}
+
 class SpiralRuntime {
   constructor(config) {
     this.config = config || {};
+    if (!this.config.token || typeof this.config.token !== 'string') {
+      throw new Error('Bot token is required. Set it in spiral.json');
+    }
     this.client = null;
     this.pluginManager = new SpiralPluginManager(this);
     this.startTime = Date.now();
     this._pluginsDir = path.join(process.cwd(), 'plugins');
+    this._unhandledHandler = null;
+    this.db = new SpiralDB(path.join(process.cwd(), 'data.json'));
   }
 
   async start() {
@@ -31,22 +135,27 @@ class SpiralRuntime {
 
   _resolveIntents() {
     const intents = this.config.intents || ['Guilds', 'GuildMessages', 'MessageContent'];
+    const map = {
+      'Guilds': GatewayIntentBits.Guilds,
+      'GuildMessages': GatewayIntentBits.GuildMessages,
+      'MessageContent': GatewayIntentBits.MessageContent,
+      'GuildMembers': GatewayIntentBits.GuildMembers,
+      'GuildVoiceStates': GatewayIntentBits.GuildVoiceStates,
+      'DirectMessages': GatewayIntentBits.DirectMessages,
+      'GuildPresences': GatewayIntentBits.GuildPresences
+    };
     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;
+      if (map[i] !== undefined) return map[i];
+      console.warn(`[runtime] Unknown intent "${i}", defaulting to Guilds`);
+      return GatewayIntentBits.Guilds;
     });
   }
 
   _bindEvents() {
     this.client.removeAllListeners();
+    if (this._unhandledHandler) {
+      process.removeListener('unhandledRejection', this._unhandledHandler);
+    }
 
     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`);
@@ -106,6 +215,12 @@ class SpiralRuntime {
     });
 
     this.client.on(Events.MessageReactionAdd, async (reaction, user) => {
+      if (reaction.partial) {
+        try { await reaction.fetch(); } catch { return; }
+      }
+      if (user.partial) {
+        try { await user.fetch(); } catch { return; }
+      }
       await this.pluginManager.emitHook('reaction_add', {
         reaction,
         user,
@@ -114,6 +229,12 @@ class SpiralRuntime {
     });
 
     this.client.on(Events.MessageReactionRemove, async (reaction, user) => {
+      if (reaction.partial) {
+        try { await reaction.fetch(); } catch { return; }
+      }
+      if (user.partial) {
+        try { await user.fetch(); } catch { return; }
+      }
       await this.pluginManager.emitHook('reaction_remove', {
         reaction,
         user,
@@ -125,35 +246,49 @@ class SpiralRuntime {
       console.error('[runtime] Error:', error.message);
     });
 
-    process.on('unhandledRejection', (error) => {
+    this._unhandledHandler = (error) => {
       console.error('[runtime] Unhandled:', error);
-    });
+    };
+    process.on('unhandledRejection', this._unhandledHandler);
   }
 
   async restart() {
     const t0 = Date.now();
     console.log('[runtime] Restarting...');
 
-    await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+    try {
+      await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+    } catch {}
 
-    this.client.destroy();
-    this.client.removeAllListeners();
+    try {
+      if (this.client) this.client.destroy();
+    } catch {}
+    if (this.client) 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`);
+    try {
+      await this.pluginManager.loadPlugins(this._pluginsDir);
+      await this.client.login(this.config.token);
+      console.log(`[runtime] Restarted in ${Date.now() - t0}ms`);
+    } catch (error) {
+      console.error('[runtime] Restart failed:', error.message);
+      throw error;
+    }
   }
 
   async stop() {
     console.log('[runtime] Shutting down...');
-    await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+    try {
+      await this.pluginManager.emitHook('bot_shutdown', { client: this.client });
+    } catch {}
     if (this.client) {
-      this.client.destroy();
+      try { this.client.destroy(); } catch {}
+    }
+    if (this._unhandledHandler) {
+      process.removeListener('unhandledRejection', this._unhandledHandler);
     }
-    process.exit(0);
   }
 
   getUptime() {
@@ -177,4 +312,4 @@ class SpiralRuntime {
   }
 }
 
-module.exports = SpiralRuntime;
+module.exports = SpiralRuntime;