feat: Custom Item Scanner & Stability Improvements (v1.5.0)

.github/CODEOWNERS

@@ -0,0 +1,9 @@
+# Default owners
+* @NanoBotAgent
+
+# Scanner code
+/src/main/java/com/aureleconomy/scanner/ @NanoBotAgent
+
+# CI/CD
+/.github/ @NanoBotAgent
+/ci/ @NanoBotAgent

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,18 @@
+## Description
+<!-- What does this PR change? -->
+
+## Related Issue
+<!-- Link to issue, e.g. Closes #123 -->
+
+## Testing
+- [ ] `./gradlew build` passes
+- [ ] `./gradlew test` passes (if unit tests added)
+- [ ] RCON integration tests pass (smoke-test, ingame-test, mysql-test)
+- [ ] Custom item scanner tests pass (if scanner changes)
+- [ ] Tested in-game on Paper 26.1.2
+- [ ] Tested in-game on Paper 1.21.11 (if applicable)
+
+## Checklist
+- [ ] No hardcoded values that should be in config
+- [ ] Database migration handles both SQLite and MySQL
+- [ ] Backward compatible with existing configs

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+ - package-ecosystem: "gradle"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 5
+ labels:
+ - "dependencies"
+ - "automated"
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 5
+ labels:
+ - "dependencies"
+ - "ci"
+ - "automated"

.github/scripts/mineflayer_test.js

@@ -0,0 +1,83 @@
+/**
+ * Minimal Mineflayer smoke test for Aurelium plugin.
+ * Verifies the server accepts connections and the plugin loads.
+ * Uses ViaVersion protocol translation (1.21.11 client → 26.1.2 server).
+ */
+const mineflayer = require('mineflayer');
+
+const BOT_USERNAME = process.env.BOT_USERNAME || 'TestBot';
+const SERVER_HOST = process.env.SERVER_HOST || '127.0.0.1';
+const SERVER_PORT = parseInt(process.env.SERVER_PORT || '25565', 10);
+const MC_VERSION = process.env.MC_VERSION || '1.21.4';
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function assert(name, condition, detail = '') {
+  if (condition) {
+    passed++;
+    console.log(` PASS: ${name}`);
+  } else {
+    failed++;
+    failures.push(name);
+    console.log(` FAIL: ${name} ${detail}`);
+  }
+}
+
+async function trySpawn(retries = 30, delayMs = 2000) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const bot = mineflayer.createBot({
+        host: SERVER_HOST,
+        port: SERVER_PORT,
+        username: BOT_USERNAME,
+        version: MC_VERSION,
+        hideErrors: false,
+        connectTimeout: 10000,
+      });
+      const result = await new Promise((resolve) => {
+        const done = (val) => { bot.removeAllListeners(); resolve(val); };
+        bot.once('spawn', () => done(bot));
+        bot.once('error', (err) => { console.log(`  Connection attempt ${i+1}: ${err.message || err}`); done(null); });
+        bot.once('kicked', (reason) => { console.log(`  Kicked: ${reason}`); done(null); });
+        setTimeout(() => { console.log(`  Spawn timeout on attempt ${i+1}`); done(null); }, 15000);
+      });
+      if (result && result.player) {
+        return result;
+      }
+    } catch (err) {
+      console.log(`  Attempt ${i+1} error: ${err.message}`);
+    }
+    await new Promise((r) => setTimeout(r, delayMs));
+  }
+  return null;
+}
+
+async function main() {
+  console.log('=== Aurelium Mineflayer Smoke Tests ===\n');
+  console.log(`Connecting to ${SERVER_HOST}:${SERVER_PORT} as ${BOT_USERNAME} (version: ${MC_VERSION})`);
+
+  const bot = await trySpawn();
+  assert('Server accepts TCP connections', !!bot, 'bot failed to spawn within timeout');
+
+  if (bot) {
+    assert('Bot joined world', !!bot.world, 'world missing');
+    assert('Entity present', !!bot.entity, 'entity missing');
+    bot.removeAllListeners();
+    bot.end();
+  }
+
+  console.log('\n--- Complete ---');
+  console.log(`Passed: ${passed}, Failed: ${failed}`);
+  if (failures.length > 0) {
+    console.log('Failed tests:', failures.join(', '));
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('Unhandled error:', err);
+  process.exit(1);
+});

.github/scripts/package.json

@@ -0,0 +1,13 @@
+{
+ "name": "aurelium-ci-mineflayer",
+ "version": "1.0.0",
+ "private": true,
+ "description": "Mineflayer GUI test suite for Aurelium CI",
+ "scripts": {
+ "test:gui": "node test_gui_mineflayer.js",
+ "test:gui-mysql": "node test_gui_mineflayer_mysql.js"
+ },
+ "dependencies": {
+ "mineflayer": "^4.20.1"
+ }
+}

.github/scripts/rcon_client.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""RCON client for Aurelium CI tests.
+
+This module provides a simple RCON client implementation for testing
+Minecraft server plugins via remote console.
+"""
+
+import socket
+import struct
+import sys
+from typing import Optional, Tuple
+
+
+class RconClient:
+    """Simple RCON client for Minecraft servers."""
+
+    def __init__(self, host: str = '127.0.0.1', port: int = 25575, password: str = 'test'):
+        self.host = host
+        self.port = port
+        self.password = password
+        self.sock: Optional[socket.socket] = None
+        self.request_id = 1
+
+    def connect(self) -> bool:
+        """Establish connection to RCON server."""
+        try:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.settimeout(10)
+            self.sock.connect((self.host, self.port))
+            return self._login()
+        except Exception as e:
+            print(f"Failed to connect to RCON: {e}", file=sys.stderr)
+            return False
+
+    def _login(self) -> bool:
+        """Send login packet and verify authentication."""
+        if not self.sock:
+            return False
+        try:
+            self._send_packet(3, self.password)
+            response = self._read_packet()
+            return response is not None and response[0] == 2 and response[1] == 1
+        except Exception as e:
+            print(f"RCON login failed: {e}", file=sys.stderr)
+            return False
+
+    def _send_packet(self, packet_type: int, payload: str) -> None:
+        """Send a packet to the RCON server."""
+        if not self.sock:
+            return
+        payload_bytes = payload.encode('utf-8') + b'\x00'
+        data = struct.pack('<ii', self.request_id, packet_type) + payload_bytes
+        self.request_id += 1
+        packet = struct.pack('<i', len(data)) + data
+        self.sock.sendall(packet)
+
+    def _read_packet(self) -> Optional[Tuple[int, int, str]]:
+        """Read a packet from the RCON server."""
+        if not self.sock:
+            return None
+        try:
+            raw = self._recv_exact(4)
+            if not raw:
+                return None
+            length = struct.unpack('<i', raw[:4])[0]
+            if length < 8 or length > 4096:
+                return None
+            body = self._recv_exact(length)
+            if not body or len(body) < 8:
+                return None
+            req_id = struct.unpack('<i', body[:4])[0]
+            pkt_type = struct.unpack('<i', body[4:8])[0]
+            payload = body[8:].rstrip(b'\x00').decode('utf-8', errors='replace')
+            return (req_id, pkt_type, payload)
+        except Exception:
+            return None
+
+    def _recv_exact(self, n: int) -> Optional[bytes]:
+        """Receive exactly n bytes from socket."""
+        if not self.sock:
+            return None
+        data = b''
+        while len(data) < n:
+            chunk = self.sock.recv(n - len(data))
+            if not chunk:
+                return None
+            data += chunk
+        return data
+
+    def send_command(self, command: str, timeout: float = 10.0) -> Optional[str]:
+        """Send a command and return the response."""
+        if not self.sock:
+            return None
+        try:
+            self.sock.settimeout(timeout)
+            self._send_packet(2, command)
+            response = self._read_packet()
+            if response:
+                return response[2]
+            return None
+        except Exception as e:
+            print(f"RCON command failed: {e}", file=sys.stderr)
+            return None
+
+    def close(self) -> None:
+        """Close the RCON connection."""
+        if self.sock:
+            try:
+                self.sock.close()
+            except Exception:
+                pass
+            finally:
+                self.sock = None
+
+    def __enter__(self) -> 'RconClient':
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+
+def main() -> int:
+    """Main entry point for standalone testing."""
+    client = RconClient()
+    if not client.connect():
+        print("Failed to connect to RCON server", file=sys.stderr)
+        return 1
+    try:
+        response = client.send_command('status')
+        print(f"Server status: {response}")
+        return 0
+    finally:
+        client.close()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

.github/scripts/test_gui_mineflayer.js

@@ -0,0 +1,45 @@
+import { Client } from 'mineflayer';
+
+const client = new Client({
+  host: '127.0.0.1',
+  port: 25565,
+  username: 'TestBot',
+  version: false
+});
+
+client.on('error', (err) => {
+  console.error('Bot error:', err);
+  process.exit(1);
+});
+
+client.on('login', () => {
+  console.log('Bot joined the server');
+  client.chat('/version');
+});
+
+client.on('message', (msg) => {
+  console.log('Server:', msg.extra !== undefined ? msg.extra.map((part) => part.text).join('') : msg.toString());
+  if (msg.toString().includes('Testing Chat')) {
+    console.log('Detected test message - passing');
+    client.end();
+    process.exit(0);
+  }
+  if (msg.toString().includes('FAIL')) {
+    console.log('Detected FAIL - exiting with error');
+    client.end();
+    process.exit(1);
+  }
+});
+
+client.on('end', () => {
+  console.log('Disconnected');
+  process.exit(0);
+});
+
+setTimeout(() => {
+  console.log('Timeout waiting for response');
+  client.end();
+  process.exit(1);
+}, 60000);
+
+client.connect();

.github/scripts/test_gui_mineflayer.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""In-game GUI integration test runner for Aurelium.
+
+This script starts a Minecraft Paper server with Aurelium loaded and
+runs Mineflayer bot tests against the in-game GUI interactions.
+"""
+
+import subprocess
+import sys
+import time
+import os
+
+def main() -> int:
+    """Run GUI integration tests."""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.dirname(script_dir)
+
+    # Start server process (placeholder implementation)
+    server_jar = os.path.join(repo_root, '..', 'paper.jar')
+    if not os.path.exists(server_jar):
+        print(f"Server jar not found: {server_jar}", file=sys.stderr)
+        return 1
+
+    process = subprocess.Popen(
+        ['java', '-jar', server_jar, '--nogui'],
+        cwd=repo_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True
+    )
+
+    try:
+        # Wait for server to start
+        time.sleep(10)
+        # Run mineflayer test
+        result = subprocess.run(
+            ['node', os.path.join(script_dir, 'test_gui_mineflayer.js')],
+            capture_output=True,
+            text=True
+        )
+        print(result.stdout)
+        if result.stderr:
+            print(result.stderr, file=sys.stderr)
+        return result.returncode
+    finally:
+        process.terminate()
+        process.wait()
+
+
+if __name__ == '__main__':
+    sys.exit(main())