v0.9.2 - 47a4a13

ServerDoctor v0.9.2

Two new analysis scanners — plugin compatibility assessment and historical performance
regression detection — both running automatically on Paper/Folia, Velocity and BungeeCord.

✨ Added

Compatibility scanner

• New CompatibilityScanner (core) that assesses each plugin against the running server and
  aggregates the signals into a transparent 0–100 risk score.
• Runtime signals (no network): declared api-version vs. the server's Minecraft version
  (Paper/Folia), whether Folia support can be confirmed, and enabled state.
• Optional external metadata feed (compatibility.metadata, off by default) adds release
  age, a Folia yes/no flag and known incompatibilities — honest by design: this data comes from
  a feed you/the community maintain, never fabricated.
• Score → severity: <15 OK · 15–39 LOW · 40–69 MEDIUM · 70–89 HIGH · ≥90 CRITICAL.
• Runs on all platforms; on proxies the Minecraft-version/Folia signals are skipped.
• PluginInfo gained an apiVersion field (populated by the Paper adapter from plugin.yml).

Historical regression detection

• New RegressionScanner (core) that compares the older half of stored performance snapshots
  against the newer half to detect gradual regressions in TPS, MSPT and RAM — catching
  slow decline over days/weeks, not just spikes.
• Uses only data already persisted, via an injected PerformanceHistory
  (limit -> storage.performance().recent(limit)).
• Runs on all platforms; on proxies TPS/MSPT (NaN) are skipped while RAM is still compared.
• Thresholds: TPS drop ≥8 %, MSPT rise ≥25 %, RAM rise ≥30 % (with HIGH/CRITICAL tiers);
  needs ≥8 stored samples. Example finding:
  Performance regression vs baseline: TPS 19.8 -> 18.4 (-7%); MSPT 14.0ms -> 23.0ms (+64%).

Both scanners surface in /serverdoctor report, the GUI, the REST /report endpoint and
webhooks (which fire on state change, so a persisting issue isn't spammed).

🔧 Changed

• ServerDoctorCore.bootstrap now accepts a single ScannerSources object bundling the optional
  advisory, compatibility and performance-history sources. The previous overloads
  (bootstrap(platform), …, AdvisorySource, …, AdvisorySource, CompatibilityMetadataSource)
  are kept and delegate to it — no caller is forced to change.
• PluginInfo gained a 7th component apiVersion; the prior 6-argument constructor is retained
  (delegates with an empty api-version), so existing adapters, tests and the REST serializer
  compile unchanged.

📦 Setup (new optional config)

compatibility:
  metadata:
    enabled: false
    feed-url: ""        # HTTPS feed (see compatibility.sample.txt)
    refresh-minutes: 1440

Regression detection needs no config — it works once PerformanceHistory is wired into
bootstrap (one line per platform; storage must be opened before bootstrap). Both scanners are
registered automatically; unwired optional sources simply stay quiet.

Full Changelog: v0.9.0...v0.9.2

v0.9.0 - b858d8d

0.9.0 - 2026-06-18

Added

• BungeeCord support: new serverdoctor-bungeecord proxy adapter (HAS_PLUGINS + IS_PROXY).
  The same universal jar now runs on Paper/Folia, Velocity and BungeeCord (plugin.yml +
  velocity-plugin.json + bungee.yml side by side), with full storage-backend selection.
• In-game GUI (/serverdoctor gui) for Paper/Folia: status overview plus Performance,
  Conflicts, Security, Recommendations and History screens, with a Refresh button.
  Folia-safe; read-only.
• Configurable automated scan (Paper/Folia) via tasks.scan
  (enabled, interval-seconds, initial-delay-seconds, warn-on-high).
• Security advisory source (all platforms, off by default): AdvisorySource +
  RemoteAdvisorySource checking installed plugins against a real, external feed
  (security.advisory). Never invents advisories.
• gui and security.advisory config sections.

Changed

• REST API and webhooks are now available on BungeeCord too (previously Paper/Velocity only);
  all three platform mains wire storage, advisory, REST and webhooks consistently.
• The hard-coded 5-minute background scan (Paper) is now config-driven.
• ServerDoctorCore.bootstrap gained an AdvisorySource overload; bootstrap(platform) is
  unchanged.

Fixed

• BungeeCord now writes its default config.yml and messages.yml on first start
  (class-relative resource loading).
• Configurable scan interval clamped to a sane minimum (10 s).

Full Changelog: v0.8.0...v0.9.0

v0.8.1 - 0c07127

ServerDoctor v0.8.1 - 0c07127

An in-game GUI and configurable automation for Paper/Folia.

✨ Added

• In-game GUI — open with /serverdoctor gui (alias /sd gui). A read-only menu with a
  status overview plus screens for Performance, Conflicts, Security,
  Recommendations and History, and a Refresh button that re-runs the analysis.
• Folia-safe by design — screens open and rebuild on the player's entity scheduler, and
  Refresh runs the analysis on the async scheduler. Clicks are routed via an InventoryHolder
  and always cancelled (nothing in the server is ever modified).
• Configurable automated scan in config.yml under tasks.scan
  (enabled, interval-seconds, initial-delay-seconds, warn-on-high) — e.g. run a full
  analysis every 120 seconds.
• gui config section (enabled, title).

🔧 Changed

• The previously hard-coded 5-minute background scan is now driven by config.yml. Defaults
  preserve the old behaviour; set your own interval (minimum 10 seconds).

🐛 Fixed

• The scan interval is clamped to a sane minimum so a misconfiguration can't hammer the server.
• Various stability and performance improvements.

📦 Setup

gui:
  enabled: true
  title: "ServerDoctor"

tasks:
  scan:
    enabled: true
    interval-seconds: 120
    initial-delay-seconds: 30
    warn-on-high: true

Open it in-game with /serverdoctor gui (permission serverdoctor.admin). The GUI is
Paper/Folia only.

Full Changelog: v0.8.0...0c07127

v0.8.0 - c86119d

ServerDoctor v0.8.0

A REST API and webhooks — get ServerDoctor's data out to your tools.

✨ Added

• REST API (serverdoctor-rest-api) — a read-only HTTP/JSON endpoint set, built on the
  JDK's HTTP server (no extra dependencies):
  • GET /health (no auth)
  • GET /performance, /conflicts, /security, /recommendations, /report
  • Optional bearer-token auth; binds to 127.0.0.1 by default.
• Webhooks (serverdoctor-webhook) — push notifications to Discord, Slack and
  Microsoft Teams (JDK HttpClient, no extra dependencies).
• Smart delivery — webhooks fire only when the status changes (new / worse /
  recovered) at or above a configurable min-severity, so the 5-minute background scan
  doesn't spam your channels.
• rest-api and webhooks sections in config.yml, on both Paper/Folia and Velocity.

🔧 Changed

• Both services are fully integrated into the Paper/Folia and Velocity adapters and shipped in
  the universal jar. They stay framework-free and depend only on the public API.

🐛 Fixed

• Webhooks no longer repeat the same alert on every scan.
• REST server threads are daemons and shut down cleanly with the plugin.
• Various stability and performance improvements.

📦 Setup

Enable the blocks in config.yml:

rest-api:
  enabled: true
  host: "127.0.0.1"
  port: 9173
  token: ""          # set a token if you expose the API

webhooks:
  enabled: true
  min-severity: HIGH
  targets:
    - type: discord
      url: "https://discord.com/api/webhooks/…"

Example request:

curl -H "Authorization: Bearer <token>" http://127.0.0.1:9173/report

Note: Microsoft is deprecating Office-365-connector webhooks for Teams. For new Teams setups,
use a Power Automate workflow webhook (it also accepts JSON POSTs).

Full Changelog: v0.6.0...v0.8.0

v0.7.0 - 04adb6b

ServerDoctor v0.7.0

Pluggable storage — pick where ServerDoctor keeps its history.

✨ Added

• New storage backends: PostgreSQL, MariaDB and MongoDB, joining the existing SQLite
  and In-Memory options. Choose any of them at runtime.
• config.yml to select the backend and enter credentials. It's created automatically on
  first start and never overwrites an existing file.
• Connection pooling (HikariCP) for the SQL backends; PostgreSQL and MariaDB share one
  provider via a small SQL-dialect abstraction.
• MongoDB via discrete host/port/username/password/auth-database fields or a full
  connection string (Atlas SRV URIs supported).
• Velocity reads the same config.yml (parsed with SnakeYAML).

🔧 Changed

• Storage is fully integrated into both the Paper/Folia and Velocity adapters. The persistence
  layer stays platform-free; the adapters build a neutral StorageConfig from your config.

🐛 Fixed

• Graceful fallback: an unreachable backend falls back to SQLite, then In-Memory, instead of
  blocking the server from starting.
• MariaDB index compatibility (indexed timestamps stored as VARCHAR(64)).
• Connection pools close cleanly on shutdown.
• Various stability and performance improvements.

📦 Setup

Set storage.type in config.yml to memory, sqlite, postgresql, mariadb or mongodb
and fill in the credentials for server-based backends. On a network, point the proxy and all
backend servers at the same database for a shared, network-wide history.

Full changelog: https://github.com/Shvquu/server-doctor/blob/main/CHANGELOG.md

v0.6.0

Changelog

All notable changes to ServerDoctor are documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/),
and this project adheres to [Semantic Versioning](https://semver.org/).

[0.6.0] - 2026-06-14

This release expands ServerDoctor from a single-platform Paper plugin into a
multi-platform diagnostics suite shipped as one universal jar, adds an update
checker and an optional PlaceholderAPI integration, and makes all user-facing
text translatable.

Added

• Folia support. The plugin detects Folia at runtime and uses a region-aware
  scheduler (FoliaSchedulerAdapter); the same Bukkit plugin now runs on both
  Paper and Folia. plugin.yml is marked folia-supported: true.
• Velocity (proxy) support. New serverdoctor-velocity module with proxy
  adapters and a /serverdoctor command. Thanks to the capability model, only
  proxy-applicable scanners run (plugin, dependency, conflict, security); the
  performance scanner is skipped automatically.
• Single universal jar. New serverdoctor-universal module shades Paper,
  Folia, and Velocity support into one jar containing both plugin.yml and
  velocity-plugin.json. Build with ./gradlew :serverdoctor-universal:shadowJar.
• Update checker. Checks GitHub releases on startup (asynchronously) and logs
  a clear console notice when a newer version is available. Available on both
  Paper/Folia and Velocity, with a configurable DISABLE_ON_UPDATE switch.
• PlaceholderAPI integration (optional). Registered only when PlaceholderAPI
  is installed — never forced. Placeholders: %serverdoctor_tps%, _mspt,
  _memory, _memory_used, _memory_max, _players, _conflicts,
  _security_risks, _recommendations, _status.
• Configurable messages (messages.yml). All command, startup, and update
  texts are externalized and translatable. The file is copied to the plugin's
  data folder on first start; missing keys fall back to the bundled defaults.
• /serverdoctor reload. Reloads messages.yml at runtime without a restart
  (permission serverdoctor.admin).

Changed

• Java 17 bytecode. The project now compiles to Java 17 (toolchain stays
  JDK 21) with api-version: 1.20. One jar therefore supports Paper/Folia from
  1.20 up to the latest version, instead of requiring Java 21.
• Build output moved. The final plugin jar is now produced by
  serverdoctor-universal rather than serverdoctor-paper (the Shadow plugin
  was removed from the Paper module).

Notes

• Dynamic scanner findings (e.g. "Low TPS: 12.4") are still generated in code and
  are not yet part of messages.yml.
• paper-api is pinned to 1.21.4; due to Bukkit's forward compatibility plus
  api-version: 1.20, the jar still runs from 1.20 to the latest. Bump the
  paper entry in libs.versions.toml if you want the newest API surface.

Still planned

• REST API and webhooks (Discord/Slack/Teams)
• PostgreSQL and MariaDB storage backends
• BungeeCord adapter
• A real security advisory source (currently a metadata heuristic)

v0.5.0

ServerDoctor v0.5.0

The first public release of ServerDoctor — the read-only analysis, diagnostics, and monitoring platform for Minecraft servers.

Read-only by design: ServerDoctor analyzes, evaluates, recommends, and warns — but never changes anything on your server. This invariant is enforced architecturally (no adapter exposes a writing method) and is locked in by automated architecture tests.

This release lays the stable foundation: engine, public API, persistence, and a fully working Paper plugin.

✨ Features

• Plugin Scanner — detects installed plugins, versions, authors, and dependencies.
• Dependency Scanner — flags missing hard dependencies.
• Conflict Scanner — matches installed plugins against an extensible conflict database (e.g. two permission or anti-cheat systems running in parallel).
• Performance Scanner — evaluates TPS, MSPT, and memory usage against thresholds.
• Security Scanner — flags plugins with incomplete metadata (an anchor point for future advisory sources).
• Recommendation Engine — turns findings into concrete, actionable recommendations.
• Public Developer API — ServerDoctorApi with access to performance, conflicts, risks, and recommendations; register your own scanners via registerModule(...).
• Event System — thread-safe EventBus with events such as AnalysisFinishedEvent, PluginConflictDetectedEvent, SecurityRiskDetectedEvent.
• Persistence — SQLite backend (default) plus an in-memory fallback; every scan is stored automatically.
• In-game commands — /serverdoctor scan | report | tps | conflicts | security | recs | history (alias /sd).
• Periodic background scan every 5 minutes (asynchronous, Folia-safe via abstraction).

🧩 Modules

Module	Contents
serverdoctor-common	Domain models, utilities
serverdoctor-api	Public contract, events, scanner SPI
serverdoctor-core	Engine, scanners, recommendations, conflict database
serverdoctor-storage	StorageProvider, repositories, SQLite + in-memory
serverdoctor-paper	Paper adapters, plugin, commands
serverdoctor-testing	Fixtures, JUnit 5 suite, ArchUnit rules

📦 Requirements

• Paper 1.21.x
• Java 21

🚀 Installation

1. Download ServerDoctor-0.5.0.jar.
2. Drop it into your Paper server's plugins/ folder.
3. Start the server — the database is created automatically at plugins/ServerDoctor/serverdoctor.db.
4. Run /serverdoctor scan to trigger the first analysis.

👩‍💻 For Developers

Other plugins can consume the API (the installed ServerDoctor plugin provides the implementation at runtime — hence compileOnly):

repositories { maven("https://jitpack.io") }
dependencies {
    compileOnly("com.github.shvquu.server-doctor:serverdoctor-api:v0.5.0")
}

if (ServerDoctorProvider.isAvailable()) {
    ServerDoctorApi api = ServerDoctorProvider.get();
    double tps = api.getPerformanceSnapshot().tps1m();
    api.events().subscribe(PluginConflictDetectedEvent.class,
            e -> getLogger().warning("Conflict: " + e.conflict().description()));
}

Set depend: [ServerDoctor] in your plugin's plugin.yml.

✅ Quality

• Full JUnit 5 test suite for core and storage.
• ArchUnit architecture tests enforce, as build breakers: no platform SDKs in the core, the clean-architecture dependency rule, and the read-only invariant.

⚠️ Not Yet Included (Planned)

• Platform adapters for Folia, Velocity, BungeeCord
• REST API and webhooks (Discord/Slack/Teams)
• PostgreSQL and MariaDB backends (SQLite + in-memory are ready)
• Update checker (Modrinth/Hangar/SpigotMC/GitHub), PlaceholderAPI bridge
• A real security advisory source (currently a metadata heuristic only)

---

Note: The API may still change before 1.0.0.

Full Changelog: https://github.com/Shvquu/server-doctor/commits/v0.5.0