lumisjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+# Lumis
+
+A powerful, feature-rich Discord bot framework with advanced capabilities including game systems, data generation, dependency injection, and more.
+
+## Features
+
+- **Advanced Client Architecture**: Built on top of Discord's API with WebSocket support
+- **Game Systems**: Built-in economy, inventory, leveling, guild management, and music systems
+- **Data Generation**: Powerful mock data generation with support for OpenAPI and GraphQL schemas
+- **Dependency Injection**: Service container for managing and injecting dependencies
+- **Advanced Caching**: Multi-level caching (Memory, Redis, SQLite) with automatic promotion/demotion
+- **Security**: Input sanitization, security middleware, rate limiting, and protection against common attacks
+- **Performance Monitoring**: Real-time CPU, memory, and event loop monitoring with alerts
+- **Health Checks**: Built-in health checker with periodic monitoring and alerts
+- **Graceful Shutdown**: Proper cleanup on shutdown with timeout handling
+- **Configuration Validation**: Schema-based configuration validation
+- **Structured Logging**: Winston-based structured logging with multiple transports
+- **Plugin System**: Extensible plugin architecture
+- **Command System**: Slash command support with interaction handling
+- **Dashboard**: Web dashboard for bot management with security headers and CSP
+- **Hot Reload**: Automatic command reloading during development
+- **Middleware & Interceptors**: Event processing pipeline
+- **Sharding**: Built-in sharding support for large bots with safe IPC communication
+- **Internationalization**: i18n support for multiple languages
+- **Error Handling**: Comprehensive error handling with custom error types
+- **Testing**: Comprehensive test suite with Jest
+
+## Installation
+
+```bash
+npm install lumis
+```
+
+## Quick Start
+
+```javascript
+const { Client, Intents } = require('lumis');
+
+const client = new Client({
+  intents: [
+    Intents.FLAGS.GUILDS,
+    Intents.FLAGS.GUILD_MESSAGES,
+  ],
+});
+
+client.on('ready', () => {
+  console.log(`Logged in as ${client.user.tag}`);
+});
+
+client.login('YOUR_BOT_TOKEN');
+```
+
+## Documentation
+
+### Core Client
+
+The `Client` class is the main entry point for your bot.
+
+```javascript
+const { Client } = require('lumis');
+
+const client = new Client({
+  intents: ['GUILDS', 'GUILD_MESSAGES'],
+  logLevel: 'debug',
+  cache: { adapter: 'memory' },
+  economy: { enabled: true },
+  music: { enabled: false },
+});
+```
+
+### Game Systems
+
+Lumis includes several game systems out of the box:
+
+#### Economy System
+
+```javascript
+client.economy.addBalance(userId, 100);
+client.economy.removeBalance(userId, 50);
+const balance = client.economy.getBalance(userId);
+```
+
+#### Inventory System
+
+```javascript
+client.inventory.addItem(userId, 'sword', { damage: 10 });
+client.inventory.removeItem(userId, 'sword');
+const items = client.inventory.getItems(userId);
+```
+
+#### Leveling System
+
+```javascript
+client.leveling.addXP(userId, 50);
+const level = client.leveling.getLevel(userId);
+```
+
+### Data Generation
+
+Generate mock data from schemas:
+
+```javascript
+const { DataGenerator, loadSchema } = require('lumis');
+
+const schema = loadSchema('./schema.json');
+const generator = new DataGenerator(schema);
+
+const data = generator.generate(10); // Generate 10 records
+```
+
+### Dependency Injection
+
+Register and inject services:
+
+```javascript
+// Register a service
+client.services.register('database', new Database());
+
+// Inject into a command
+class MyCommand extends Command {
+  inject = ['database'];
+  
+  async execute(interaction) {
+    const data = await this.database.query('SELECT * FROM users');
+  }
+}
+```
+
+### Caching
+
+Configure different cache adapters:
+
+```javascript
+const client = new Client({
+  cache: {
+    adapter: 'redis', // or 'memory', 'sqlite'
+    options: {
+      host: 'localhost',
+      port: 6379,
+    },
+  },
+});
+```
+
+### Plugin System
+
+Create and load plugins:
+
+```javascript
+// Load a plugin
+client.plugins.load('./plugins/my-plugin');
+
+// Plugin structure
+module.exports = {
+  name: 'my-plugin',
+  version: '1.0.0',
+  load(client) {
+    // Initialize plugin
+  },
+  unload(client) {
+    // Cleanup
+  },
+};
+```
+
+## API Reference
+
+### Classes
+
+- **Client**: Main bot client
+- **ServiceContainer**: Dependency injection container
+- **CacheManager**: Unified cache management with metrics
+- **MultiLevelCache**: Advanced tiered caching with auto promotion/demotion
+- **MemoryAdapter**: In-memory cache with LRU eviction
+- **RedisAdapter**: Redis cache with pub/sub for distributed invalidation
+- **SQLiteAdapter**: Persistent SQLite cache with transactions
+- **InputSanitizer**: Input validation and sanitization
+- **SecurityMiddleware**: Rate limiting, IP blocking, and request validation
+- **PerformanceMonitor**: Real-time performance metrics and alerts
+- **HealthChecker**: Health monitoring with periodic checks
+- **GracefulShutdown**: Graceful shutdown handler with cleanup
+- **ConfigValidator**: Schema-based configuration validation
+- **StructuredLogger**: Winston-based structured logging
+- **PluginManager**: Plugin system
+- **CommandManager**: Command handling
+- **DataGenerator**: Mock data generation
+- **EconomyManager**: Economy system
+- **InventoryManager**: Inventory system
+- **LevelingSystem**: Leveling system
+- **GameSessionManager**: Game session management
+- **GuildManager**: Guild management
+- **MusicManager**: Music playback
+- **DashboardManager**: Web dashboard with security
+
+### Errors
+
+- **LumisError**: Base error class
+- **APIError**: API-related errors
+- **WebSocketError**: WebSocket connection errors
+- **RateLimitError**: Rate limit errors
+
+## Project Structure
+
+```
+lumis/
+├── src/
+│   ├── cache/          # Cache adapters
+│   ├── client/         # Main client
+│   ├── config/         # Configuration validation
+│   ├── dashboard/      # Dashboard system
+│   ├── datagen/        # Data generation
+│   ├── di/             # Dependency injection
+│   ├── errors/         # Error handling
+│   ├── game/           # Game systems
+│   ├── guards/         # Route guards
+│   ├── health/         # Health monitoring
+│   ├── interactions/   # Command handling
+│   ├── interceptors/   # Event interceptors
+│   ├── middleware/     # Middleware
+│   ├── performance/    # Performance monitoring
+│   ├── plugins/        # Plugin system
+│   ├── rest/           # REST API
+│   ├── security/       # Security middleware
+│   ├── shutdown/       # Graceful shutdown
+│   ├── structures/     # Data structures
+│   ├── utils/          # Utilities
+│   └── ws/             # WebSocket
+├── tests/              # Test files
+├── data/               # Data files
+├── examples/           # Example schemas
+└── index.js            # Entry point
+```
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Development Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run linter
+npm run lint
+
+# Format code
+npm run format
+```
+
+## Security
+
+Lumis takes security seriously. Key security features include:
+
+- **Input Sanitization**: All user input is automatically sanitized to prevent XSS and injection attacks
+- **Rate Limiting**: Built-in rate limiting to prevent abuse
+- **Security Headers**: Dashboard includes comprehensive security headers (CSP, XSS protection, etc.)
+- **Safe Sharding**: IPC communication uses registered handlers only, no arbitrary code execution
+- **No Dynamic Code**: Dangerous `eval()` and `new Function()` usage has been eliminated
+
+See [SECURITY.md](SECURITY.md) for detailed security information and best practices.
+
+## License
+
+MIT License - see LICENSE file for details.

package/SECURITY.md

@@ -0,0 +1,160 @@
+# Security Policy
+
+## Overview
+
+Lumis takes security seriously and implements multiple layers of protection to ensure safe operation.
+
+## Security Features
+
+### Input Sanitization
+
+All user input is sanitized using the `InputSanitizer` class to prevent:
+- XSS attacks
+- SQL injection
+- Command injection
+- Path traversal
+
+```javascript
+const { InputSanitizer } = require('lumis');
+
+const sanitized = InputSanitizer.sanitize(userInput, {
+  allowHTML: false,
+  allowScript: false,
+  maxLength: 1000,
+});
+```
+
+### Security Middleware
+
+The `SecurityMiddleware` class provides:
+- Rate limiting
+- IP blocking
+- Request size validation
+- Suspicious pattern detection
+
+```javascript
+const { SecurityMiddleware } = require('lumis');
+
+const security = new SecurityMiddleware({
+  maxRequestSize: 1024 * 1024, // 1MB
+  rateLimitWindow: 60000, // 1 minute
+  rateLimitMax: 100,
+});
+
+// Use with Express
+app.use(security.createMiddleware());
+```
+
+### Safe Sharding
+
+**IMPORTANT**: IPC communication uses registered handlers only. Arbitrary code execution is not supported.
+
+Use the safe `broadcastAction` method with registered handlers:
+
+```javascript
+// Register a handler
+client.registerBroadcastHandler('getStats', () => ({
+  guilds: client.guilds.size,
+  users: client.users.size,
+}));
+
+// Use safe broadcast
+const stats = await manager.broadcastAction('getStats');
+```
+
+### Cache Security
+
+- No arbitrary code execution in cache operations
+- TTL-based automatic expiration
+- Pattern-based invalidation
+- Backup/restore with validation
+
+### Dashboard Security
+
+The dashboard includes:
+- Authentication via Bearer tokens
+- Security headers (CSP, XSS protection, frame options)
+- CORS configuration
+- Rate limiting
+
+## Security Headers
+
+The dashboard automatically sets the following security headers:
+
+- `X-Content-Type-Options: nosniff`
+- `X-Frame-Options: DENY`
+- `X-XSS-Protection: 1; mode=block`
+- `Strict-Transport-Security: max-age=31536000; includeSubDomains`
+- `Content-Security-Policy: default-src 'self'`
+
+## Best Practices
+
+### 1. Never Hardcode Tokens
+
+Always use environment variables:
+
+```javascript
+const token = process.env.DISCORD_TOKEN;
+```
+
+### 2. Validate All Input
+
+```javascript
+const { InputSanitizer } = require('lumis');
+
+function handleUserInput(input) {
+  const sanitized = InputSanitizer.sanitize(input);
+  // Process sanitized input
+}
+```
+
+### 3. Use Rate Limiting
+
+```javascript
+const { SecurityMiddleware } = require('lumis');
+
+const security = new SecurityMiddleware({
+  rateLimitMax: 100,
+  rateLimitWindow: 60000,
+});
+```
+
+### 4. Enable Authentication
+
+Always enable authentication on the dashboard:
+
+```javascript
+const client = new Client({
+  dashboard: {
+    enabled: true,
+    auth: process.env.DASHBOARD_AUTH,
+  },
+});
+```
+
+### 5. Keep Dependencies Updated
+
+Regularly update dependencies:
+
+```bash
+npm audit
+npm audit fix
+npm update
+```
+
+## Reporting Security Issues
+
+If you discover a security vulnerability, please:
+
+1. Do not create a public issue
+2. Email security details to the maintainers
+3. Include steps to reproduce
+4. Allow time for the issue to be fixed before disclosing
+
+## Security Audits
+
+This project undergoes regular security audits to identify and fix vulnerabilities.
+
+## License
+
+This security policy is part of the Lumis project and is licensed under the MIT License.

package/index.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * Lumis - A powerful Discord bot framework
+ *
+ * @module Lumis
+ */
+
+const Client = require('./src/client/Client');
+const { LumisError, APIError, WebSocketError, RateLimitError } = require('./src/errors/LumisError');
+const { ErrorCodes } = require('./src/errors/ErrorCodes');
+const ServiceContainer = require('./src/di/ServiceContainer');
+const { CacheManager, MemoryAdapter, RedisAdapter, SQLiteAdapter, MultiLevelCache } = require('./src/cache');
+const { InputSanitizer, SecurityMiddleware } = require('./src/security');
+const { PerformanceMonitor } = require('./src/performance');
+
+// Data generation module
+const {
+  DataGenerator,
+  loadSchema,
+  formatters,
+  PluginManager: DataGenPluginManager,
+  mockFromOpenApi,
+  mockFromGraphqlSchema,
+} = require('./src/datagen');
+
+// Game systems
+const EconomyManager = require('./src/game/EconomyManager');
+const InventoryManager = require('./src/game/InventoryManager');
+const LevelingSystem = require('./src/game/LevelingSystem');
+const GameSessionManager = require('./src/game/GameSessionManager');
+const GuildManager = require('./src/game/GuildManager');
+const MusicManager = require('./src/game/MusicManager');
+
+// Dashboard
+const DashboardManager = require('./src/dashboard/DashboardManager');
+
+module.exports = {
+  // Core
+  Client,
+
+  // Errors
+  LumisError,
+  APIError,
+  WebSocketError,
+  RateLimitError,
+  ErrorCodes,
+
+  // Dependency Injection
+  ServiceContainer,
+
+  // Caching
+  CacheManager,
+  MemoryAdapter,
+  RedisAdapter,
+  SQLiteAdapter,
+  MultiLevelCache,
+  
+  // Security
+  InputSanitizer,
+  SecurityMiddleware,
+  
+  // Performance
+  PerformanceMonitor,
+  
+  // Health & Monitoring
+  HealthChecker,
+  GracefulShutdown,
+  ConfigValidator,
+  StructuredLogger,
+
+  // Data Generation
+  DataGenerator,
+  loadSchema,
+  formatters,
+  PluginManager: DataGenPluginManager,
+  mockFromOpenApi,
+  mockFromGraphqlSchema,
+
+  // Game Systems
+  EconomyManager,
+  InventoryManager,
+  LevelingSystem,
+  GameSessionManager,
+  GuildManager,
+  MusicManager,
+
+  // Dashboard
+  DashboardManager,
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "lumisjs",
+  "version": "1.0.0",
+  "description": "A powerful, feature-rich Discord bot framework with advanced capabilities including game systems, data generation, dependency injection, security, performance monitoring, health checks, and more.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix",
+    "format": "prettier --write \"src/**/*.js\" \"tests/**/*.js\"",
+    "format:check": "prettier --check \"src/**/*.js\" \"tests/**/*.js\"",
+    "prepare": "husky install || true"
+  },
+  "keywords": [
+    "discord",
+    "bot",
+    "framework",
+    "discord.js",
+    "gaming",
+    "economy",
+    "music",
+    "dashboard",
+    "sharding",
+    "data-generation",
+    "security",
+    "caching",
+    "performance",
+    "monitoring",
+    "health-checks",
+    "graceful-shutdown",
+    "logging",
+    "middleware"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/username/lumis"
+  },
+  "bugs": {
+    "url": "https://github.com/username/lumis/issues"
+  },
+  "homepage": "https://github.com/username/lumis#readme",
+  "dependencies": {
+    "ws": "^8.14.0",
+    "helmet": "^7.1.0",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0",
+    "prettier": "^3.0.0",
+    "jest": "^29.7.0",
+    "husky": "^8.0.3"
+  },
+  "files": [
+    "src/",
+    "index.js",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md"
+  ]
+}