spiralcord-full 2.1.0 → 2.2.7

package/src/test.js

@@ -1,5 +1,4 @@
 const fs = require('fs').promises;
-const fsSync = require('fs');
 const path = require('path');
 
 class SpiralTester {
@@ -147,31 +146,59 @@ class SpiralTester {
       const commandsMatch = code.match(/commands\s*:\s*\{/);
       const hooksMatch = code.match(/hooks\s*:\s*\{/);
       const apiMatch = code.match(/api\s*:\s*\{/);
+      const keywordsMatch = code.match(/keywords\s*:\s*\{/);
+      const initMatch = code.match(/init\s*:/);
 
-      if (!commandsMatch && !hooksMatch && !apiMatch) {
-        result.issues.push('No commands, hooks, or api exported');
-        this.warnings.push(`${name}: No commands, hooks, or api exported`);
+      if (!commandsMatch && !hooksMatch && !apiMatch && !keywordsMatch && !initMatch) {
+        result.issues.push('No commands, hooks, api, keywords, or init exported');
+        this.warnings.push(`${name}: No commands, hooks, api, keywords, or init exported`);
       }
 
       if (commandsMatch) {
-        const cmdRegex = /(\w+)\s*:\s*\{/g;
-        let match;
-        while ((match = cmdRegex.exec(code)) !== null) {
-          if (match[1] !== 'commands' && match[1] !== 'hooks' && match[1] !== 'api' && match[1] !== 'init') {
-            result.commands++;
-            this.allCommands.set(match[1], name);
+        const cmdBlockStart = code.indexOf(commandsMatch[0]);
+        if (cmdBlockStart !== -1) {
+          let depth = 0;
+          let blockContent = '';
+          let inBlock = false;
+          for (let i = cmdBlockStart; i < code.length; i++) {
+            if (code[i] === '{') { depth++; inBlock = true; }
+            if (inBlock) blockContent += code[i];
+            if (code[i] === '}') { depth--; if (depth === 0) break; }
+          }
+
+          const cmdRegex = /(\w+)\s*:\s*\{/g;
+          let match;
+          while ((match = cmdRegex.exec(blockContent)) !== null) {
+            if (match[1] !== 'commands' && match[1] !== 'hooks' && match[1] !== 'api' && match[1] !== 'init') {
+              result.commands++;
+              if (!this.allCommands.has(match[1])) this.allCommands.set(match[1], []);
+              this.allCommands.get(match[1]).push(name);
+            }
           }
         }
       }
 
       if (hooksMatch) {
-        const hookRegex = /(\w+)\s*:\s*async\s*\(/g;
-        let match;
-        while ((match = hookRegex.exec(code)) !== null) {
-          if (['message_received', 'bot_ready', 'interaction_received', 'presence_update', 'guild_joined', 'guild_left', 'voice_state_update', 'reaction_add', 'reaction_remove', 'bot_shutdown'].includes(match[1])) {
-            result.hooks++;
-            if (!this.allHooks.has(match[1])) this.allHooks.set(match[1], []);
-            this.allHooks.get(match[1]).push(name);
+        const hookBlockStart = code.indexOf(hooksMatch[0]);
+        if (hookBlockStart !== -1) {
+          let depth = 0;
+          let blockContent = '';
+          let inBlock = false;
+          for (let i = hookBlockStart; i < code.length; i++) {
+            if (code[i] === '{') { depth++; inBlock = true; }
+            if (inBlock) blockContent += code[i];
+            if (code[i] === '}') { depth--; if (depth === 0) break; }
+          }
+
+          const knownHooks = ['message_received', 'bot_ready', 'interaction_received', 'presence_update', 'guild_joined', 'guild_left', 'voice_state_update', 'reaction_add', 'reaction_remove', 'bot_shutdown'];
+          const hookRegex = /(\w+)\s*:\s*async\s*(?:\(|function\s*\()/g;
+          let match;
+          while ((match = hookRegex.exec(blockContent)) !== null) {
+            if (knownHooks.includes(match[1])) {
+              result.hooks++;
+              if (!this.allHooks.has(match[1])) this.allHooks.set(match[1], []);
+              this.allHooks.get(match[1]).push(name);
+            }
           }
         }
       }
@@ -179,13 +206,13 @@ class SpiralTester {
       const requireMatches = code.match(/require\(['"]([^'"]+)['"]\)/g);
       if (requireMatches) {
         for (const req of requireMatches) {
-          const module = req.match(/require\(['"]([^'"]+)['"]\)/)[1];
-          if (module.startsWith('.') || module.startsWith('/')) continue;
+          const mod = req.match(/require\(['"]([^'"]+)['"]\)/)[1];
+          if (mod.startsWith('.') || mod.startsWith('/')) continue;
           try {
-            require.resolve(module);
+            require.resolve(mod, { paths: [path.dirname(indexPath)] });
           } catch {
-            result.issues.push(`Missing dependency: ${module}`);
-            this.warnings.push(`${name}: Missing dependency - ${module}`);
+            result.issues.push(`Missing dependency: ${mod}`);
+            this.warnings.push(`${name}: Missing dependency - ${mod}`);
           }
         }
       }
@@ -215,17 +242,22 @@ class SpiralTester {
 
         if (line === '' || line.startsWith('#')) continue;
 
-        if (line.startsWith('COMMAND ')) {
-          const match = line.match(/COMMAND\s+(\S+)\s+"([^"]+)"/);
+        if (line.startsWith('COMMAND ') || line.startsWith('SLASH_COMMAND ')) {
+          const pattern = line.startsWith('SLASH_COMMAND ')
+            ? /SLASH_COMMAND\s+(\S+)\s+"([^"]+)"/
+            : /COMMAND\s+(\S+)\s+"([^"]+)"/;
+          const match = line.match(pattern);
           if (!match) {
             result.status = 'error';
-            result.issues.push(`Line ${i + 1}: Invalid COMMAND syntax`);
-            this.errors.push(`${name}: Line ${i + 1} - Invalid COMMAND syntax`);
+            const keyword = line.startsWith('SLASH_COMMAND') ? 'SLASH_COMMAND' : 'COMMAND';
+            result.issues.push(`Line ${i + 1}: Invalid ${keyword} syntax. Use: ${keyword} name "description"`);
+            this.errors.push(`${name}: Line ${i + 1} - Invalid ${keyword} syntax`);
           } else {
             inCommand = true;
             commandName = match[1];
             result.commands++;
-            this.allCommands.set(commandName, name);
+            if (!this.allCommands.has(commandName)) this.allCommands.set(commandName, []);
+            this.allCommands.get(commandName).push(name);
           }
         } else if (line === 'END') {
           if (inResponsePool) {
@@ -238,11 +270,10 @@ class SpiralTester {
           if (line.startsWith('RESPONSE_POOL')) {
             inResponsePool = true;
           } else if (!inResponsePool) {
-            if (!line.startsWith('ALIASES') && !line.startsWith('COOLDOWN') &&
-                !line.startsWith('REQUIRES') && !line.startsWith('RESPONSE ') &&
-                !line.startsWith('EMBED') && !line.startsWith('TITLE') &&
-                !line.startsWith('DESCRIPTION')) {
-              result.issues.push(`Line ${i + 1}: Unknown DSL keyword: ${line.split(' ')[0]}`);
+            const validKeywords = ['ALIASES', 'COOLDOWN', 'REQUIRES_ARGS', 'REQUIRES_PERMISSION', 'RESPONSE', 'EMBED', 'TITLE', 'DESCRIPTION', 'BUTTON', 'SELECT', 'DB_SET', 'DB_GET', 'DB_ADD', 'DB_DELETE', 'DB_RESPONSE'];
+            const firstWord = line.split(' ')[0];
+            if (!validKeywords.includes(firstWord)) {
+              result.issues.push(`Line ${i + 1}: Unknown DSL keyword: ${firstWord}`);
               this.warnings.push(`${name}: Line ${i + 1} - Unknown DSL keyword`);
             }
           }
@@ -273,10 +304,11 @@ class SpiralTester {
     const hasSchema = await this.fileExists(configSchemaPath);
     const hasConfig = await this.fileExists(configPath);
 
+    let schema = null;
     if (hasSchema) {
       try {
         const schemaData = await fs.readFile(configSchemaPath, 'utf-8');
-        JSON.parse(schemaData);
+        schema = JSON.parse(schemaData);
       } catch (e) {
         result.issues.push(`Invalid config.schema.json: ${e.message}`);
         this.warnings.push(`${name}: Invalid config.schema.json`);
@@ -288,28 +320,21 @@ class SpiralTester {
         const configData = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configData);
 
-        if (hasSchema) {
-          try {
-            const schemaData = await fs.readFile(configSchemaPath, 'utf-8');
-            const schema = JSON.parse(schemaData);
-
-            if (schema.properties) {
-              for (const [key, prop] of Object.entries(schema.properties)) {
-                if (prop.type === 'string' && config[key] !== undefined && typeof config[key] !== 'string') {
-                  result.issues.push(`Config "${key}" should be string, got ${typeof config[key]}`);
-                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
-                }
-                if (prop.type === 'number' && config[key] !== undefined && typeof config[key] !== 'number') {
-                  result.issues.push(`Config "${key}" should be number, got ${typeof config[key]}`);
-                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
-                }
-                if (prop.type === 'boolean' && config[key] !== undefined && typeof config[key] !== 'boolean') {
-                  result.issues.push(`Config "${key}" should be boolean, got ${typeof config[key]}`);
-                  this.warnings.push(`${name}: Config "${key}" type mismatch`);
-                }
-              }
+        if (schema && schema.properties) {
+          for (const [key, prop] of Object.entries(schema.properties)) {
+            if (prop.type === 'string' && config[key] !== undefined && typeof config[key] !== 'string') {
+              result.issues.push(`Config "${key}" should be string, got ${typeof config[key]}`);
+              this.warnings.push(`${name}: Config "${key}" type mismatch`);
+            }
+            if (prop.type === 'number' && config[key] !== undefined && typeof config[key] !== 'number') {
+              result.issues.push(`Config "${key}" should be number, got ${typeof config[key]}`);
+              this.warnings.push(`${name}: Config "${key}" type mismatch`);
             }
-          } catch {}
+            if (prop.type === 'boolean' && config[key] !== undefined && typeof config[key] !== 'boolean') {
+              result.issues.push(`Config "${key}" should be boolean, got ${typeof config[key]}`);
+              this.warnings.push(`${name}: Config "${key}" type mismatch`);
+            }
+          }
         }
       } catch (e) {
         result.issues.push(`Invalid config.json: ${e.message}`);
@@ -321,12 +346,9 @@ class SpiralTester {
   }
 
   checkCommandConflicts() {
-    const seen = new Map();
-    for (const [cmd, plugin] of this.allCommands) {
-      if (seen.has(cmd)) {
-        this.warnings.push(`Command conflict: "${cmd}" in ${seen.get(cmd)} and ${plugin}`);
-      } else {
-        seen.set(cmd, plugin);
+    for (const [cmd, plugins] of this.allCommands) {
+      if (plugins.length > 1) {
+        this.warnings.push(`Command conflict: "${cmd}" in ${plugins.join(', ')}`);
       }
     }
   }
@@ -348,9 +370,9 @@ class SpiralTester {
     }
   }
 
-  async fileExists(path) {
+  async fileExists(filePath) {
     try {
-      await fs.access(path);
+      await fs.access(filePath);
       return true;
     } catch {
       return false;
@@ -358,4 +380,4 @@ class SpiralTester {
   }
 }
 
-module.exports = SpiralTester;
+module.exports = SpiralTester;

package/src/types/index.d.ts

@@ -0,0 +1,100 @@
+export interface SpiralConfig {
+  name: string;
+  token: string;
+  prefix: string;
+  intents: string[];
+  clientId: string;
+  disabledCommands: string[];
+}
+
+export interface SpiralPluginManifest {
+  name: string;
+  version: string;
+  description: string;
+  author?: string;
+  dependencies?: Record<string, string>;
+  collision_policy?: 'error' | 'first-wins' | 'last-wins';
+  builtin?: boolean;
+}
+
+export interface SpiralPluginConfig {
+  [key: string]: any;
+}
+
+export interface SpiralCommand {
+  description: string;
+  usage?: string;
+  aliases?: string[];
+  slash?: boolean;
+  priority?: number;
+  execute: (message: any, args: string[], runtime: SpiralRuntime) => Promise<void>;
+}
+
+export interface SpiralHooks {
+  bot_ready?: (payload: { client: any; user: any; config: SpiralConfig }, runtime: SpiralRuntime) => Promise<void>;
+  message_received?: (payload: { message: any; user: any; guild: any; channel: any }, runtime: SpiralRuntime) => Promise<void>;
+  interaction_received?: (payload: { interaction: any; user: any; guild: any; channel: any }, runtime: SpiralRuntime) => Promise<void>;
+  presence_update?: (payload: { oldPresence: any; newPresence: any; user: any; guild: any }, runtime: SpiralRuntime) => Promise<void>;
+  voice_state_update?: (payload: { oldState: any; newState: any; user: any; guild: any }, runtime: SpiralRuntime) => Promise<void>;
+  reaction_add?: (payload: { reaction: any; user: any; message: any }, runtime: SpiralRuntime) => Promise<void>;
+  reaction_remove?: (payload: { reaction: any; user: any; message: any }, runtime: SpiralRuntime) => Promise<void>;
+  guild_joined?: (payload: { guild: any }, runtime: SpiralRuntime) => Promise<void>;
+  guild_left?: (payload: { guild: any }, runtime: SpiralRuntime) => Promise<void>;
+  bot_shutdown?: (payload: { client: any }, runtime: SpiralRuntime) => Promise<void>;
+  [key: string]: ((payload: any, runtime: SpiralRuntime) => Promise<void>) | undefined;
+}
+
+export interface SpiralPlugin {
+  init?: (config: SpiralPluginConfig, runtime: SpiralRuntime) => Promise<void>;
+  commands?: Record<string, SpiralCommand>;
+  keywords?: Record<string, (message: any, args: string[], runtime: SpiralRuntime) => Promise<void>>;
+  hooks?: SpiralHooks;
+  api?: Record<string, (...args: any[]) => any>;
+}
+
+export interface SpiralDB {
+  get(key: string, defaultValue?: any): any;
+  set(key: string, value: any): any;
+  add(key: string, amount: number): number;
+  delete(key: string): boolean;
+  has(key: string): boolean;
+  all(): Record<string, any>;
+  clear(): void;
+}
+
+export interface SpiralRuntime {
+  config: SpiralConfig;
+  client: any;
+  db: SpiralDB;
+  startTime: number;
+  start(): Promise<void>;
+  restart(): Promise<void>;
+  stop(): Promise<void>;
+  getUptime(): number;
+  getCommand(name: string): any;
+  getAllCommands(): Map<string, any>;
+  getPluginConfig(pluginName: string): SpiralPluginConfig;
+  getPluginAPI(pluginName: string): Record<string, (...args: any[]) => any> | null;
+  emitHook(eventName: string, payload: any): Promise<void>;
+  emitHookSerial(eventName: string, payload: any): Promise<void>;
+  emitHookWithResult(eventName: string, payload: any): Promise<boolean>;
+}
+
+export interface SpiralTester {
+  test(): Promise<{
+    passed: number;
+    warnings: number;
+    errors: number;
+    results: Array<{
+      name: string;
+      status: 'ok' | 'warning' | 'error';
+      commands: number;
+      hooks: number;
+      issues: string[];
+    }>;
+    details: {
+      warnings: string[];
+      errors: string[];
+    };
+  }>;
+}

package/src/web/server.js

@@ -10,12 +10,33 @@ class SpiralWeb {
     this.server = http.createServer(this.app);
     this.port = process.env.PORT || 3000;
 
-    this.app.use(express.json());
+    this.app.use(express.json({ limit: '1mb' }));
+
+    this.app.use((req, res, next) => {
+      res.setHeader('X-Content-Type-Options', 'nosniff');
+      res.setHeader('X-Frame-Options', 'DENY');
+      res.setHeader('X-XSS-Protection', '1; mode=block');
+      next();
+    });
+
     this.app.use(express.static(path.join(__dirname, 'public')));
 
     this.setupRoutes();
   }
 
+  _sanitizeName(name) {
+    if (!name || typeof name !== 'string') return null;
+    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '');
+    if (sanitized !== name || sanitized.length === 0 || sanitized.length > 100) return null;
+    if (sanitized.includes('..') || sanitized.startsWith('.')) return null;
+    return sanitized;
+  }
+
+  _sanitizeError(error) {
+    const msg = error.message || String(error);
+    return msg.replace(/\/[^\s:]+/g, '[path]');
+  }
+
   setupRoutes() {
     this.app.get('/api/config', (req, res) => {
       try {
@@ -27,65 +48,57 @@ class SpiralWeb {
           res.json({ success: true, config: {} });
         }
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
     this.app.post('/api/config', (req, res) => {
       try {
         const { config } = req.body;
+        if (!config || typeof config !== 'object' || Array.isArray(config)) {
+          return res.status(400).json({ success: false, error: 'Config must be a JSON object' });
+        }
         const configPath = path.join(process.cwd(), 'spiral.json');
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
         res.json({ success: true });
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
     this.app.get('/api/plugins', (req, res) => {
       try {
         const pluginsDir = path.join(process.cwd(), 'plugins');
-        const builtinDir = path.join(__dirname, '..', 'plugins', 'builtin');
-
         const plugins = [];
 
-        if (fs.existsSync(builtinDir)) {
-          const folders = fs.readdirSync(builtinDir);
-          for (const folder of folders) {
-            const manifestPath = path.join(builtinDir, folder, 'plugin.json');
-            if (fs.existsSync(manifestPath)) {
-              const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-              plugins.push({ ...manifest, builtin: true, source: 'builtin' });
-            }
-          }
-        }
-
         if (fs.existsSync(pluginsDir)) {
-          const folders = fs.readdirSync(pluginsDir);
+          const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+          const folders = entries.filter(e => e.isDirectory() && !e.name.startsWith('.'));
           for (const folder of folders) {
-            const manifestPath = path.join(pluginsDir, folder, 'plugin.json');
-            if (fs.existsSync(manifestPath)) {
-              const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-              plugins.push({ ...manifest, builtin: false, source: 'user' });
-            }
+            try {
+              const manifestPath = path.join(pluginsDir, folder.name, 'plugin.json');
+              if (fs.existsSync(manifestPath)) {
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                plugins.push({ ...manifest, builtin: false, source: 'user' });
+              }
+            } catch {}
           }
         }
 
         res.json({ success: true, plugins });
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
     this.app.get('/api/plugins/:name', (req, res) => {
       try {
-        const name = req.params.name;
-        let pluginPath = path.join(__dirname, '..', 'plugins', 'builtin', name);
-
-        if (!fs.existsSync(pluginPath)) {
-          pluginPath = path.join(process.cwd(), 'plugins', name);
+        const name = this._sanitizeName(req.params.name);
+        if (!name) {
+          return res.status(400).json({ success: false, error: 'Invalid plugin name' });
         }
 
+        const pluginPath = path.join(process.cwd(), 'plugins', name);
         if (!fs.existsSync(pluginPath)) {
           return res.status(404).json({ success: false, error: 'Plugin not found' });
         }
@@ -106,20 +119,23 @@ class SpiralWeb {
 
         res.json({ success: true, manifest, configSchema, config });
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
     this.app.put('/api/plugins/:name/config', (req, res) => {
       try {
-        const name = req.params.name;
-        const { config } = req.body;
+        const name = this._sanitizeName(req.params.name);
+        if (!name) {
+          return res.status(400).json({ success: false, error: 'Invalid plugin name' });
+        }
 
-        let pluginPath = path.join(__dirname, '..', 'plugins', 'builtin', name);
-        if (!fs.existsSync(pluginPath)) {
-          pluginPath = path.join(process.cwd(), 'plugins', name);
+        const { config } = req.body;
+        if (!config || typeof config !== 'object' || Array.isArray(config)) {
+          return res.status(400).json({ success: false, error: 'Config must be a JSON object' });
         }
 
+        const pluginPath = path.join(process.cwd(), 'plugins', name);
         if (!fs.existsSync(pluginPath)) {
           return res.status(404).json({ success: false, error: 'Plugin not found' });
         }
@@ -128,7 +144,7 @@ class SpiralWeb {
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
         res.json({ success: true });
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
@@ -142,7 +158,11 @@ class SpiralWeb {
 
     this.app.get('/api/plugins/:name/api', (req, res) => {
       try {
-        const name = req.params.name;
+        const name = this._sanitizeName(req.params.name);
+        if (!name) {
+          return res.status(400).json({ success: false, error: 'Invalid plugin name' });
+        }
+
         const api = this.runtime?.pluginManager?.getPluginAPI(name);
         if (api) {
           res.json({ success: true, api: Object.keys(api) });
@@ -150,7 +170,7 @@ class SpiralWeb {
           res.json({ success: true, api: [] });
         }
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
 
@@ -165,20 +185,28 @@ class SpiralWeb {
         }
         res.json({ success: true, hooks });
       } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
+        res.status(500).json({ success: false, error: this._sanitizeError(error) });
       }
     });
   }
 
   start() {
+    this.server.on('error', (error) => {
+      if (error.code === 'EADDRINUSE') {
+        console.error(`Port ${this.port} is already in use`);
+      } else {
+        console.error('Server error:', error.message);
+      }
+    });
+
     this.server.listen(this.port, () => {
       console.log(`Spiralcord Web Manager running at http://localhost:${this.port}`);
     });
   }
 
-  stop() {
-    this.server.close();
+  stop(callback) {
+    this.server.close(callback);
   }
 }
 
-module.exports = SpiralWeb;
+module.exports = SpiralWeb;