feat: Improve docs

Author: HttpRafa

.devcontainer/Dockerfile

@@ -10,6 +10,7 @@ RUN apt update && apt upgrade -y
 # Install necessary packages
 RUN apt install -y \
     build-essential git gh \
+    mkdocs-material \
     protobuf-compiler \
     rustup \
     openjdk-21-jdk gradle

.devcontainer/devcontainer.json

@@ -26,6 +26,5 @@
             ]
         }
     },
-    "remoteUser": "${localEnv:USER:code}",
-    "postStartCommand": "cargo clean"
+    "remoteUser": "${localEnv:USER:code}"
 }

Dockerfile

@@ -18,7 +18,7 @@ RUN cargo build -p controller --features wasm-plugins --release
 FROM alpine:latest
 
 # Install necessary runtime dependencies
-RUN apk add --no-cache curl unzip
+RUN apk add --no-cache curl unzip openjdk21-jre
 
 # Set the working directory
 WORKDIR /app

docker-compose.yml

@@ -12,9 +12,11 @@ services:
       - PTERODACTYL=true
       - LOCAL=true
     volumes:
-      - ./run/logs:/app/logs
-      - ./run/auth:/app/auth
+      - ./run/certs:/app/certs
       - ./run/configs:/app/configs
-      - ./run/nodes:/app/nodes
       - ./run/groups:/app/groups
-      - ./run/plugins:/app/plugins
+      - ./run/logs:/app/logs
+      - ./run/nodes:/app/nodes
+      - ./run/plugins:/app/plugins
+      - ./run/users:/app/users
+      - ./run/data:/app/data

docs/api/jvm/channels.md

@@ -8,7 +8,6 @@ Channels are a pub/sub (publish/subscribe) messaging system within Atomic Cloud
 - [Prerequisites](#prerequisites)
 - [Receiving Messages](#receiving-messages)
 - [Sending Messages](#sending-messages)
-- [Conclusion](#conclusion)
 
 ## What Are Channels?
 
@@ -34,13 +33,12 @@ To receive messages from a channel, subscribe and register a message handler usi
 ### Example
 
 ```java
-// Subscribe to the "party/invites" channel
-Cloud.channels().subscribe("party/invites");
-
-// Register a handler to process incoming messages on "party/invites"
-Cloud.channels().registerHandler("party/invites", (message) -> {
-    // Define your message handling logic here
-    System.out.println("Received message: " + message);
+var channel = Cloud.channels().subscribeToStrings("testChannel");
+channel.handler(message -> {
+  // A message was received from the channel.
+});
+channel.errorHandler(throwable -> {
+  // Oh no! An error occurred while trying to receive a message from the channel.
 });
 ```
 
@@ -53,12 +51,7 @@ Sending messages is simple. Use the API to send a message to a channel, and all
 ### Example
 
 ```java
-// Send a message to the "party/invites" channel
-Cloud.channels().sendMessage("party/invites", "test");
+Cloud.channels().publishString("testChannel", "MESSAGE");
 ```
 
-In this example, the string `"test"` is broadcast to all clients subscribed to the "party/invites" channel.
-
-## Conclusion
-
-Channels in Atomic Cloud offer a robust and secure method for inter‑server communication, allowing you to easily implement real‑time features with minimal setup. By following the steps above, you can integrate channels into your project to enable seamless, efficient messaging between distributed services.
+In this example, the string `"MESSAGE"` is broadcast to all clients subscribed to the "testChannel" channel.

docs/api/jvm/index.md

@@ -11,23 +11,35 @@ To include the API in a **Maven** project, add the following dependency to your
 <dependency>
     <groupId>io.atomic.cloud</groupId>
     <artifactId>api</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
+    <version>0.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 ### **Gradle**
 For **Gradle** projects, add the following dependency to your `build.gradle.kts` file:
 
 ```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        url = uri("https://maven.pkg.github.com/HttpRafa/atomic-cloud")
+        name = "GitHub Packages"
+        credentials {
+            username = project.findProperty("gpr.username") as String?
+            password = project.findProperty("gpr.password") as String?
+        }
+    }
+}
+
 dependencies {
-    implementation("io.atomic.cloud:api:0.1.0-SNAPSHOT")
+    implementation("io.atomic.cloud:api:0.7.0-SNAPSHOT")
 }
 ```
 
 If you're using Groovy-based Gradle (`build.gradle`), use:
 
 ```gradle
 dependencies {
-    implementation 'io.atomic.cloud:api:0.1.0-SNAPSHOT'
+    implementation 'io.atomic.cloud:api:0.7.0-SNAPSHOT'
 }
 ```

docs/usage/cli/index.md docs/cli/index.mddocs/usage/cli/index.md renamed to docs/cli/index.md

@@ -1,24 +1,22 @@
-# Command Line Interface (CLI)
+# What is the CLI?
 
-This guide provides instructions on how to download, install, and use the CLI tool for managing the controller.
+The **CLI** is an essential part of Atomic Cloud. Similar to how `kubectl` functions for Kubernetes, the CLI allows you to manage the cloud without needing to provide everyone with SSH access to the server.
 
-## Download the CLI
+# Installation
+This guide provides instructions on how to download, install, and use the CLI tool for managing the controller.
 
+## Step 1: Download
 Download the latest CLI binary from the [GitHub releases page](https://github.com/HttpRafa/atomic-cloud/releases/).
 
-## Installation
-
-1. **Download:**  
-   Choose and download the binary appropriate for your operating system.
-2. **Set Up PATH:**  
-   Place the downloaded binary in a directory that is included in your system's PATH. This ensures you can run the CLI from any terminal session.
+## Step 2: Set Up PATH
+Place the downloaded binary in a directory that is included in your system's PATH. This ensures you can run the CLI from any terminal session.
 
-## Usage
+# Usage
 
 - **Launching the CLI:**  
   Open your terminal and run the CLI command.
 - **Interactive Guidance:**  
-  Follow the on-screen instructions provided by the CLI to control the controller and manage your cloud resources.
+  Follow the on-screen instructions provided by the CLI to control the controller and manage your cloud network.
 
 > **Note:**  
 > We’re actively working to expand and enhance this documentation. Please check back soon for more detailed content and additional usage examples.

docs/controller/image/first_startup.png

@@ -0,0 +1,80 @@
+# What is the Controller?
+
+The **Controller** is a vital component of Atomic Cloud. It acts as the central management server by:
+
+- **Overseeing Nodes:**  
+  It monitors and manages the nodes.
+
+- **Managing Servers:**  
+  It is responsible for initiating and supervising the servers launched by the cloud.
+
+---
+
+# Docker Installation (Recommended)
+
+The most straightforward method to install the controller is by utilizing a Docker image. Follow the steps below to set it up using Docker Compose:
+
+## Step 1: Create the `docker-compose.yml` File
+First, use a text editor to create the `docker-compose.yml` file:
+```bash
+nano docker-compose.yml
+```
+Next, add the following content to the file:
+```yaml
+services:
+  controller:
+    image: ghcr.io/httprafa/atomic-cloud:latest
+    ports:
+      - "8080:8080"
+    environment:
+      - PTERODACTYL=true # Enable Pterodactyl plugin installation
+      - LOCAL=true       # Enable Local plugin installation
+    volumes:
+      - ./certs:/app/certs
+      - ./configs:/app/configs
+      - ./groups:/app/groups
+      - ./logs:/app/logs
+      - ./nodes:/app/nodes
+      - ./plugins:/app/plugins
+      - ./users:/app/users
+      - ./data:/app/data
+```
+
+## Step 2: Start the Container
+To start the container, execute the following command:
+```bash
+docker compose up
+```
+
+---
+
+# Manual Installation
+
+Follow the steps below to manually install Atomic Cloud.
+
+## Step 1: Download the CLI and Controller
+
+ Download the latest release from our [GitHub releases page](https://github.com/HttpRafa/atomic-cloud/releases).
+
+ **Controller:** Choose the version that corresponds to the operating system where the Controller will run.
+
+ **CLI:** Choose the version that matches the operating system on your local machine, from which you will manage the cloud.
+
+## Step 2: Start the Controller
+
+1. Open a terminal and navigate to the directory where the Controller is located.
+2. Start the Controller.
+3. **Important:** After startup, note the authentication token that is displayed. You will need this token later.  
+   If you lose the token, you can retrieve it from our [token retrieval guide](../usage/controller/retrieve_token.md).
+
+## Step 3: Download and Install the Plugin
+
+1. Download the latest plugin version from our [GitHub releases page](https://github.com/HttpRafa/atomic-cloud/releases).
+2. Place the plugin file into the `plugins` folder.
+3. Restart the Controller to load the new plugin.
+
+## Step 4: Start the CLI
+
+1. Open a terminal on your local device where you want to control the cloud.
+2. Start the CLI application.
+3. When prompted, select **"Add new controller"** and follow the on-screen instructions to complete the setup.

docs/controller/index.md

@@ -1,11 +1,9 @@
 ## Retrieve the Admin Token on First Launch
 
-When you run the controller for the first time, an admin token will be displayed in the console. You will need this token to connect via the CLI. For more information, please refer to the [How to use the CLI](../usage/cli/index.md) guide.
-
-![First Startup](images/first_startup.png)
-
+When you run the controller for the first time, an admin token will be displayed in the console. You will need this token to connect via the CLI. For more information, please refer to the [How to use the CLI](../cli/index.md) guide.
 
+![First Startup](image/first_startup.png)
 
 ## Retrieve the Admin Token After the First Launch
 
-If you lose the token after the initial launch, you can retrieve it from the default admin user's file. The file is located in the `auth/users` directory within your controller's installation folder.
+If you lose the token after the initial launch, you can retrieve it from the default admin user's file. The file is located in the `users` directory within your controller's installation folder.