Dashboard (v2.5) (#57)

This is a pull request that will add a simple Dashboard, plus a little restructuring of the folders. This pull request is bringing a big change to Mongoose's schemas and later there will be a script to migrate it. # Git Commit messages * Code init * Add node_env in docker ci/C's test * Create global.css * Push Code * Cookies * Fix Cookie Auth * Code Changes * Dashboard: Change Login and Lougout and Add navbar * Dashboard: Change Login and Lougout and Add navbar * change to Routes * Dashboard: Users * Dashboard Changes * Devcontainer * Push * Push * Devcontainer * Changes to Service Init * Push * Init move mongo scripts * Remote await in ServiceInit * Push * Change Mongo and Schema and Encrypt mode. * Dashboard: SSH Monitor init. * Push * Update Dockerfile * Dashboard
2022-01-25 23:33:09 -03:00
parent 4ed6b48e05
commit b87b9d00c3
48 changed files with 4497 additions and 783 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -0,0 +1,50 @@
+{
+	"name": "ofvpserver",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"target": "devcontainer"
+	},
+  "forwardPorts": [
+		3000
+	],
+	"hostRequirements": {
+		"cpus": 2,
+		"memory": "2gb",
+		"storage": "128gb"
+	},
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "npm install --no-save",
+	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "devcontainer",
+  "runArgs": [
+    "--privileged",
+		"-v",
+		"/var/run/docker.sock:/var/run/docker.sock"
+  ],
+	"extensions": [
+		"akamud.vscode-theme-onedark",
+		"formulahendry.auto-rename-tag",
+		"hookyqr.beautify",
+		"aaron-bond.better-comments",
+		"wmaurer.change-case",
+		"oouo-diogo-perdigao.docthis",
+		"dbaeumer.vscode-eslint",
+		"me-dutour-mathieu.vscode-github-actions",
+		"github.copilot",
+		"benshabatnoam.google-translate-ext",
+		"oderwat.indent-rainbow",
+		"tgreen7.vs-code-node-require",
+		"eg2.vscode-npm-script",
+		"christian-kohler.npm-intellisense",
+		"ionutvmi.path-autocomplete",
+		"christian-kohler.path-intellisense",
+		"esbenp.prettier-vscode",
+		"rangav.vscode-thunder-client",
+		"visualstudioexptteam.vscodeintellicode",
+		"vscode-icons-team.vscode-icons",
+		"redhat.vscode-yaml",
+		"eamodio.gitlens",
+		"mongodb.mongodb-vscode",
+		"ms-azuretools.vscode-docker"
+	]
+}
--- a/.github/workflows/root.yml
+++ b/.github/workflows/root.yml
@ -37,7 +37,7 @@ jobs:
        run: docker build -t ghcr.io/ofvp-project/server:nightly .

      - name: Up Docker Container
-        run: docker run --rm --name ofvp_server -e MongoDB_URL="mongodb://${{ env.mongodbip }}:27017" ghcr.io/ofvp-project/server:nightly -- --debug
+        run: docker run --rm --name ofvp_server -e MongoDB_URL="mongodb://${{ env.mongodbip }}:27017" -e NODE_ENV="development" ghcr.io/ofvp-project/server:nightly -- --debug
  
  Release:
    runs-on: ubuntu-latest
@ -69,6 +69,7 @@ jobs:
        with:
          context: .
          push: true
+          target: server
          tags: ghcr.io/ofvp-project/server:latest
          platforms: ${{ env.docker_archs }}
  
@ -102,6 +103,7 @@ jobs:
        with:
          context: .
          push: true
+          target: server
          tags: ghcr.io/ofvp-project/server:nightly
          platforms: ${{ env.docker_archs }}

--- a/.gitignore
+++ b/.gitignore
@ -1,5 +1,6 @@
 # Others Files
 node_modules/
 *.env
+*.env.*
 Test*
 test*
--- a/.gitpod.yml
+++ b/.gitpod.yml
@ -0,0 +1,12 @@
+
+image:
+  file: Dockerfile
+  context: devcontainer
+tasks:
+  - init: npm install
+ports:
+  - port: 3000
+    visibility: public
+vscode:
+  extensions:
+    - dbaeumer.vscode-eslint
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -1,4 +1,6 @@
 {
    "editor.tabSize": 2,
-    "files.autoSaveDelay": 5
+    "files.autoSaveDelay": 5,
+    "files.autoSave": "afterDelay",
+    "files.eol": "\n"
 }
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@ -0,0 +1,14 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build",
+      "command": "node",
+      "type": "shell",
+      "args": [
+        "dev.js",
+        "--build"
+      ]
+    }
+  ]
+}
--- a/62
+++ b/62
@ -1,5 +1,4 @@
-# Servers
-FROM ubuntu:latest AS servers
+FROM ubuntu:latest AS base
 ENV DEBIAN_FRONTEND="noninteractive"
 LABEL name="OFVp Server"
 LABEL org.opencontainers.image.title="OFVp Server"
@ -14,11 +13,6 @@ EXPOSE 22/tcp 80/tcp 7300/tcp 51820/udp 3000/tcp
 # Install Core Packages
 RUN apt update && apt -y install build-essential wget curl git unzip zip zsh sudo jq screen nano ca-certificates net-tools bc lsof dos2unix nload zlib1g-dev ifupdown iputils-ping iproute2 tzdata openssl ntp procps openresolv inotify-tools gnupg libc6 libelf-dev perl pkg-config figlet python3 python python3-pip

-# Install BadVPN
-RUN RELEASE_TAG="$(curl -Ssl https://api.github.com/repos/OFVp-Project/BadvpnBin/releases/latest | grep 'tag_name' | cut -d '"' -f 4)"; \
-wget "https://github.com/OFVp-Project/BadvpnBin/releases/download/${RELEASE_TAG}/badvpn-udpgw-$(uname -m)" -O /usr/bin/badvpn-udpgw && \
-chmod +x -v /usr/bin/badvpn-udpgw
-
 # Change bash to zsh
 RUN usermod --shell /usr/bin/zsh root

@ -32,29 +26,43 @@ echo resolvconf resolvconf/linkify-resolvconf boolean false | debconf-set-select
 apt-get -y install resolvconf && \
 apt -y install wireguard-tools iptables iproute2 resolvconf qrencode dkms wireguard

-# Install v2ray
-RUN \
-  V2RAY_VERSION="$(curl -Ssl https://api.github.com/repos/v2fly/v2ray-core/releases/latest | grep 'tag_name' | cut -d '"' -f 4)"; \
-  case "$(uname -m)" in \
-    x86_64) V2RAY_PLATFORM="64";; \
-    aarch64) V2RAY_PLATFORM="arm64-v8a";; \
-    armv7l) V2RAY_PLATFORM="arm32-v7a";; \
-    *) echo "Unknown architecture: $(uname -m)"; exit 1;; \
-  esac && \
-  wget "https://github.com/v2fly/v2ray-core/releases/download/${V2RAY_VERSION}/v2ray-linux-${V2RAY_PLATFORM}.zip" -O /tmp/v2ray.zip && \
-  mkdir -p /opt/v2ray && \
-  unzip /tmp/v2ray.zip -d /opt/v2ray && \
-  rm -fv /tmp/v2ray.zip
-
 # Install latest NodeJS
-RUN curl -fsSL https://deb.nodesource.com/setup_lts.x | bash - && apt install -y nodejs && npm install -g npm@latest
+ARG NODEJSCHANELL="lts"
+RUN curl -fsSL "https://deb.nodesource.com/setup_${NODEJSCHANELL}.x" | bash - && apt install -y nodejs && npm install -g npm@latest

-# Copy and Install Dependecies
+# Install BadVPN
+RUN \
+BADVPNTAG="$(curl -Ssl https://api.github.com/repos/OFVp-Project/BadvpnBin/releases/latest | grep 'tag_name' | cut -d \" -f 4)";\
+echo "Downloading from URL: https://github.com/OFVp-Project/BadvpnBin/releases/download/${BADVPNTAG}/badvpn-udpgw-$(uname -m)"; \
+wget "https://github.com/OFVp-Project/BadvpnBin/releases/download/${BADVPNTAG}/badvpn-udpgw-$(uname -m)" -O /usr/bin/badvpn-udpgw && \
+chmod +x -v /usr/bin/badvpn-udpgw
+
+FROM base AS devcontainer
+# Add user and setup User
+RUN adduser --disabled-password --gecos "" --shell /usr/bin/zsh devcontainer && \
+usermod -aG sudo devcontainer && echo "devcontainer ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
+
+# Install Docker and Docker Compose
+RUN curl https://get.docker.com | sh && \
+compose_version="$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep tag_name | cut -d \" -f 4)"; \
+wget https://github.com/docker/compose/releases/download/${compose_version}/docker-compose-`uname -s`-`uname -m` -O /usr/local/bin/docker-compose && \
+chmod +x /usr/local/bin/docker-compose
+RUN mkdir /workspace && chown -Rv devcontainer:devcontainer /workspace && chmod 7777 -Rv /workspace
+USER devcontainer
+WORKDIR /home/devcontainer
+
+# Install oh my zsh
+RUN yes | sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)" && \
+git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ~/.oh-my-zsh/custom/plugins/zsh-syntax-highlighting && \
+git clone https://github.com/zsh-users/zsh-autosuggestions ~/.oh-my-zsh/custom/plugins/zsh-autosuggestions && \
+sed -e 's|ZSH_THEME=".*"|ZSH_THEME="strug"|g' -i ~/.zshrc && \
+sed -e 's|plugins=(.*)|plugins=(git docker zsh-syntax-highlighting zsh-autosuggestions)|g' -i ~/.zshrc
+
+# Server Entrys
+FROM base AS server
 WORKDIR /usr/src/Backend
-
-# Copy Backend Control
 COPY package*.json ./
 RUN npm install --no-save
-ENTRYPOINT [ "node", "--no-warnings", "src/index.js" ]
-ENV MongoDB_URL="mongodb://ofvp_mongodb:27017"
+ENTRYPOINT [ "npm", "run", "start" ]
+ENV MongoDB_URL="mongodb://localhost:27017" NODE_ENV="production" COOKIE_SECRET="OFVpServer"
 COPY ./ ./
--- a/NextDashboard/.gitignore
+++ b/NextDashboard/.gitignore
@ -0,0 +1 @@
+.next/
--- a/NextDashboard/components/NetworkStatics.jsx
+++ b/NextDashboard/components/NetworkStatics.jsx
@ -0,0 +1,74 @@
+import { useEffect, useState } from "react";
+
+function NetworkStatic() {
+  /**
+   * @type {[[
+   * {
+   *   interfaceName: String;
+   *   rxBytes: Number;
+   *   txBytes: Number;
+   *   parsed: {
+   *     rx: {value: Number;unit: "Kb"|"Mb"|"Gb"|"Tb"|"..."};
+   *     tx: {value: Number;unit: "Kb"|"Mb"|"Gb"|"Tb"|"..."};
+   *   }
+   * }
+   * ]]}
+   */
+  const [Static, setStatic] = useState([]);
+  useEffect(async () => {
+    while (true) {
+      setStatic(await (await fetch("/v2/Network/Stats")).json());
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }, [setStatic])
+  return (
+    <div>
+      {
+        Static.length === 0 ? <span>No Network Stats</span> : Static.map((Interface, index1) => {
+          return (
+            <div key={index1}>
+              <span>{Interface.interfaceName}</span>
+              <ul>
+                <li>RX: {Interface.parsed.rx.value} {Interface.parsed.rx.unit}</li>
+                <li>TX: {Interface.parsed.tx.value} {Interface.parsed.tx.unit}</li>
+              </ul>
+            </div>
+          )
+        })
+      }
+    </div>
+  )
+}
+
+function Nload() {
+  /**
+   * @type {[[
+   * {
+   *   interface: String;
+   *   rxBytes: {value: Number;unit: "Bps"|"Kbps"|"Mbps"|"Gbps"|"Tbps"|"...bps"}
+   *   txBytes: {value: Number;unit: "Bps"|"Kbps"|"Mbps"|"Gbps"|"Tbps"|"...bps"}
+   * }
+   * ]]}
+   */
+  const [nload, Setnload] = useState([]);
+  useEffect(async () => {
+    while (true) {
+      Setnload(await (await fetch("/v2/Network/nload")).json());
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  }, [Setnload]);
+  return nload.length === 0 ? <span>No</span> : nload.map((Interface, Index1) => {
+    return (
+      <div key={Index1}>
+        <span>{Interface.interface}</span>
+        <ul>
+          <li>RX: {Interface.rxBytes.value} {Interface.rxBytes.unit}</li>
+          <li>TX: {Interface.txBytes.value} {Interface.txBytes.unit}</li>
+        </ul>
+      </div>
+    )
+  })
+}
+
+export default NetworkStatic;
+export {NetworkStatic, Nload};
--- a/NextDashboard/components/nav.jsx
+++ b/NextDashboard/components/nav.jsx
@ -0,0 +1,37 @@
+import Link from "next/link";
+import React from "react";
+
+export default class Nav extends React.Component {
+  render() {
+    return (
+      <>
+        {/* create navbar */}
+        <nav className="navbar navbar-expand-lg navbar-dark bg-dark">
+          <div className="container-fluid">
+            <Link href="/">
+              <a className="navbar-brand">OFVp Server</a>
+            </Link>
+            <button className="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNavDropdown" aria-controls="navbarNavDropdown" aria-expanded="false" aria-label="Toggle navigation">
+              <span className="navbar-toggler-icon"></span>
+            </button>
+            <div className="collapse navbar-collapse" id="navbarNavDropdown">
+              <ul className="navbar-nav">
+                <li className="nav-item">
+                  <Link href="/Users">
+                    <a className="nav-link">Users</a>
+                  </Link>
+                </li>
+                <li className="nav-item">
+                  <a className="nav-link" onClick={() => document.getElementById("LogoutButtonID").click()}>Logout</a>
+                </li>
+              </ul>
+            </div>
+          </div>
+        </nav>
+        <form action="/v2/TokenManeger/CookieLogout?redirect=/Dashboard/login" method="post" style={{display: "none"}}>
+          <button type="submit" id="LogoutButtonID">Logout</button>
+        </form>
+      </>
+    )
+  }
+}
--- a/NextDashboard/next.config.js
+++ b/NextDashboard/next.config.js
@ -0,0 +1,23 @@
+const os = require("os");
+
+module.exports = {
+  reactStrictMode: false,
+  swcMinify: true,
+  basePath: "/Dashboard",
+  env: {
+    os_cpus: JSON.stringify(os.cpus()),
+    os_hostname: os.hostname(),
+    os_platform: os.platform(),
+    os_release: os.release(),
+    os_type: os.type(),
+    os_arch: os.arch(),
+    os_totalmem: os.totalmem()
+  },
+  images: {
+    domains: [
+      "localhost",
+      "avatars.githubusercontent.com",
+      "raw.githubusercontent.com",
+    ]
+  }
+}
--- a/NextDashboard/pages/404.js
+++ b/NextDashboard/pages/404.js
@ -0,0 +1,14 @@
+function Page404() {
+  return (
+    <>
+      <h1>404</h1>
+      <p>
+        The page you are looking for does not exist.
+      </p>
+    </>
+  )
+}
+
+
+
+export default Page404;
--- a/NextDashboard/pages/Users/index.jsx
+++ b/NextDashboard/pages/Users/index.jsx
@ -0,0 +1,169 @@
+import { useEffect, useState } from "react";
+import { useRouter } from "next/router";
+
+function Users_SSH() {
+  /**
+   * @type {[{
+   *  BackendDate: string;
+   *  Users: Array<{
+   *    Username: string;
+   *    expire: string;
+   *    Max_Connections: number;
+   *    connections: Array<{
+   *        CPU: number;
+   *        Started: string;
+   *        TimeConnected: {
+   *            seconds: number;
+   *            minutes: number;
+   *            hours: number;
+   *            days: number;
+   *            weeks: number;
+   *            months: number;
+   *            years: number;
+   *        };
+   *    }>;
+   *  }>;
+   *}]}
+   */
+  const [SshMonitor, setSshMonitor] = useState({"BackendDate": "", "Users": []});
+  useEffect(async () => {
+    while(true) {
+      setSshMonitor(await (await fetch("/v2/Network/ssh_monitor")).json());
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }, [setSshMonitor]);
+  return (
+    <div className="card-columns">
+      {
+        SshMonitor.Users.length === 0 ? (<span>No users</span>) :
+          SshMonitor.Users.map((user, index) => {
+            return (
+              <div className="card" key={index}>
+                <div className="card-body">
+                    <h5 className="card-title">{user.Username}</h5>
+                    <button className="btn btn-danger" onClick={async () => {
+                      if (confirm(`Are you sure you want to remove ${user.Username}?`)) {
+                        const Response = await fetch("/v2/Users/", {method: "DELETE", headers: {"Content-Type": "application/json"}, body: JSON.stringify({Username: user.Username})});
+                        Response.ok ? alert(`${user.Username} has been removed`) : alert(`${user.Username} could not be removed`);
+                      }
+                    }}>Delete</button>
+                    <p className="card-text">{user.connections.length === 0 ? <span style={{color: "red"}}>No Connections</span>:user.connections.map((Connection, index2) => {
+                      const { seconds, minutes, hours, days, weeks, months, years } = Connection.TimeConnected;
+                      return (
+                        <div key={index2}>
+                          <span>{Connection.CPU}%</span>
+                          <ul>
+                            {seconds > 0 ? <li>{seconds} seconds</li> : null}
+                            {minutes > 0 && seconds > 0 ? <li>{minutes} minutes</li> : null}
+                            {hours > 0 && minutes > 0 ? <li>{hours} hours</li> : null}
+                            {days > 0 && hours > 0 ? <li>{days} days</li> : null}
+                            {weeks > 0 && days > 0 ? <li>{weeks} weeks</li> : null}
+                            {months > 0 && weeks > 0 ? <li>{months} months</li> : null}
+                            {years > 0 && months > 0 ? <li>{years} years</li> : null}
+                          </ul>
+                        </div>
+                      )
+                    })}</p>
+                </div>
+              </div>
+            )
+          })
+        }
+    </div>
+  )
+}
+
+function Users() {
+  const [InfinetConnections, setInfinetConnections] = useState(true);
+  const Querys = (useRouter()).query||{};
+  return (
+    <>
+      <div>
+        <h1>Add Users</h1>
+        {
+          (() => {
+            const {username, expire, password_iv, password_Encrypt, ssh_connections, wireguard_keys_Preshared, wireguard_keys_Private, wireguard_keys_Public, wireguard_ip_v4_ip, wireguard_ip_v4_mask, wireguard_ip_v6_ip, wireguard_ip_v6_mask, wireguard_load} = Querys;
+            if (username) {
+              return (
+                <>
+                  <div className="alert alert-success" role="alert">
+                    <h4 className="alert-heading">Well done!</h4>
+                    <span className="text-muted">Username: {username}</span>
+                    <br />
+                    <span className="text-muted">Will be removed on the day: {
+                      (() => {
+                        const date = new Date(expire);
+                        return `${date.getDate()}/${date.getMonth()}/${date.getFullYear()}`;
+                      })()
+                    }</span>
+                    <br />
+                    <span className="text-muted">Password, iv: {password_iv}, DataEncryt: {password_Encrypt}</span>
+                    <br />
+                    <span className="text-muted">SSH Max Connections: {ssh_connections}</span>
+                    <br />
+                    <span className="text-muted">Wireguard is Avaible: {wireguard_load}</span>
+                    {
+                      wireguard_load === "true" ? (
+                        <ul>
+                          <li className="text-muted">Preshared key: {wireguard_keys_Preshared}</li>
+                          <li className="text-muted">Private key: {wireguard_keys_Private}</li>
+                          <li className="text-muted">Public key: {wireguard_keys_Public}</li>
+                          <li className="text-muted">IPv4: {wireguard_ip_v4_ip}/{wireguard_ip_v4_mask}</li>
+                          <li className="text-muted">IPV6: {wireguard_ip_v6_ip}/{wireguard_ip_v6_mask}</li>
+                        </ul>
+                      ) : null
+                    }
+                  </div>
+                </>
+              )
+            }
+            return null;
+          })()
+        }
+        <form method="post" action="/v2/Users?redirect=/Dashboard/Users">
+          <div className="form-group">
+            <label htmlFor="username">Username</label>
+            <input type="text" className="form-control" id="username" name="Username" placeholder="Enter username" required minLength="6" />
+          </div>
+          <div className="form-group">
+            <label htmlFor="password">Password</label>
+            <input type="password" className="form-control" id="password" name="Password" placeholder="Enter password" required minLength="8" maxLength="16" />
+          </div>
+          <div className="form-group">
+            <label htmlFor="expire">Expire</label>
+            <input type="date" className="form-control" id="expire" name="ExpireDate" placeholder="Enter expire" defaultValue={(() => {
+              const DaD = new Date(new Date().getTime()+(1000*60*60*24*5));
+              return `${DaD.getFullYear()}-${DaD.getMonth()+1}-${DaD.getDate()}`;
+            })()} min={(() => {
+              const DaD = new Date(new Date().getTime()+(1000*60*60*24*5));
+              return `${DaD.getFullYear()}-${DaD.getMonth()+1}-${DaD.getDate()}`;
+            })()} max={(() => {
+              const DaD = new Date(new Date().getTime()+(1000*60*60*24*28*12*365*15));
+              return `${DaD.getFullYear()}-${DaD.getMonth()+1}-${DaD.getDate()}`;
+            })()} />
+          </div>
+          <div className="form-group">
+            <input type="checkbox" className="form-check-input" id="infiniteConnections" defaultChecked onChange={(e) => e.target.checked ? setInfinetConnections(true) : setInfinetConnections(false)} />
+            <label className="form-check-label" htmlFor="infiniteConnections">Infinite Connections?</label>
+            {
+              InfinetConnections ?
+                <input type="hidden" className="form-control" id="infiniteConnections" name="Connections" defaultValue="0" placeholder="Enter connections" />
+              :
+                <input type="number" className="form-control" id="infiniteConnections" name="Connections" defaultValue="5" placeholder="Enter infinite connections" required />
+            }
+          </div>
+          <br/>
+          <button type="submit" className="btn btn-primary">Submit</button>
+        </form>
+      </div>
+      <br/>
+      <br/>
+      <div>
+        <h2>SSH Monitor</h2>
+        <br />
+        <Users_SSH />
+      </div>
+    </>
+  );
+}
+export default Users;
--- a/NextDashboard/pages/_app.js
+++ b/NextDashboard/pages/_app.js
@ -0,0 +1,38 @@
+import { pageProps } from "next/app";
+import "../styles/global.css";
+import { useRouter } from "next/router";
+import Head from "next/head";
+import Navbar from "../components/nav";
+/**
+ * @param {pageProps} param0 
+ * @returns 
+ */
+function DashboardMainRender({ Component, pageProps }) {
+  const Querys = (useRouter()).query;
+  return (
+    <>
+      <Head>
+        <title>Dashboard</title>
+        <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-ka7Sk0Gln4gmtz2MlQnikT1wXgYsOg+OMhuP+IlRH9sENBO0LRn5q+8nbTov4+1p" crossOrigin="anonymous"></script>
+      </Head>
+      <Navbar />
+      {Querys.Error ? <div className="alert alert-danger">{
+        Querys.Error.split("\n").map((value, key) => {
+          return (
+            <span key={key}>
+              {value.replace(/\\t|\t/gi, "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;")}
+              <br/>
+            </span>
+          )
+        })
+      }</div> : null}
+      {Querys.noLogged ? <div className="alert alert-danger">You are not logged in</div> : null}
+      {Querys.AuthStatus === "true" ? <div className="alert alert-success">You are logged in</div> : null}
+      <div className="container-fluid">
+        <Component {...pageProps} />
+      </div>
+    </>
+  );
+}
+
+export default DashboardMainRender;
--- a/NextDashboard/pages/index.jsx
+++ b/NextDashboard/pages/index.jsx
@ -0,0 +1,69 @@
+import React from "react";
+import { NetworkStatic, Nload } from "../components/NetworkStatics";
+export default class Home extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      SshMonitor: {
+        "version": "Lodding...",
+        "Nodejs_Version": "Lodding...",
+        "Services": {
+          "Running": [
+            "Lodding..."
+          ],
+          "Offline": [
+            "Lodding..."
+          ]
+        },
+        "HostInfo": {
+          "hostname": "Lodding...",
+          "arch": "Lodding...",
+          "cpu": {
+            "cores": 0,
+            "Model": "Lodding..."
+          }
+        }
+      }
+    };
+  }
+  componentDidMount() {
+    (async()=>{
+      const Info = await fetch("/info");
+      this.setState({
+        SshMonitor: await Info.json()
+      });
+    })();
+  }
+  render() {
+    return (
+      <>
+        <h1>Hello to OFVp Dashboard</h1>
+        <br/>
+        <h2>Network Data Transfere</h2>
+        <NetworkStatic />
+        <br/>
+        <h2>nload (live network traffic)</h2>
+        <Nload />
+        <br/>
+        <h2>Services Reunning</h2>
+        <ul>
+          {this.state.SshMonitor.Services.Running.map((service, index) => (
+            <li key={index}>{service}</li>
+          ))}
+        </ul>
+        <h2>Services Offline</h2>
+        <ul>
+          {this.state.SshMonitor.Services.Offline.map((service, index) => (
+            <li key={index}>{service}</li>
+          ))}
+        </ul>
+        <h2>Host Info</h2>
+        <ul>
+          <li>Hostname: {this.state.SshMonitor.HostInfo.hostname}</li>
+          <li>Arch: {this.state.SshMonitor.HostInfo.arch}</li>
+          <li>CPU: {this.state.SshMonitor.HostInfo.cpu.Model}, Cores: {this.state.SshMonitor.HostInfo.cpu.cores}</li>
+        </ul>
+      </>
+    );
+  }
+}
--- a/NextDashboard/pages/login.jsx
+++ b/NextDashboard/pages/login.jsx
@ -0,0 +1,38 @@
+const logo = "https://avatars.githubusercontent.com/u/91811821?s=200&v=4";
+import Login from "../styles/Login.module.css";
+
+function LoginReact() {
+  return (
+    <>
+      <div className={Login["login-page"]}>
+        <div className={Login["login-page-container"]}>
+          <div className={Login["login-page-header"]}>
+            <img src={logo} alt="logo" />
+          </div>
+          <div className={Login["login-page-body"]}>
+            <div className={Login["login-page-body-container"]}>
+              <div className={Login["login-page-body-container-header"]}>
+                <h1>Login</h1>
+              </div>
+              <form action="/v2/TokenManeger/CookieLogin?redirect=/Dashboard" method="post" className={Login["login-page-body-container-body"]}>
+                <div className={Login["login-page-body-container-body-form"]}>
+                  <div className={Login["login-page-body-container-body-form-input"]}>
+                    <input type="text" name="Email" placeholder="Email" />
+                  </div>
+                  <div className={Login["login-page-body-container-body-form-input"]}>
+                    <input type="password" name="Password" placeholder="Password" />
+                  </div>
+                  <div className={Login["login-page-body-container-body-form-button"]}>
+                    <input type="submit" value="Login" />
+                  </div>
+                </div>
+              </form>
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+}
+LoginReact.isAuth = true;
+export default LoginReact;
--- a/NextDashboard/pages/register.jsx
+++ b/NextDashboard/pages/register.jsx
@ -0,0 +1,38 @@
+const logo = "https://avatars.githubusercontent.com/u/91811821?s=200&v=4";
+import Login from "../styles/Login.module.css";
+
+function registerLogin() {
+  return (
+    <>
+      <div className={Login["login-page"]}>
+        <div className={Login["login-page-container"]}>
+          <div className={Login["login-page-header"]}>
+            <img src={logo} alt="logo" />
+          </div>
+          <div className={Login["login-page-body"]}>
+            <div className={Login["login-page-body-container"]}>
+              <div className={Login["login-page-body-container-header"]}>
+                <h1>Register Token</h1>
+              </div>
+              <form action="/v2/TokenManeger/token?redirect=/Dashboard" method="post" className={Login["login-page-body-container-body"]}>
+                <div className={Login["login-page-body-container-body-form"]}>
+                  <div className={Login["login-page-body-container-body-form-input"]}>
+                    <input type="text" name="Email" placeholder="Email" />
+                  </div>
+                  <div className={Login["login-page-body-container-body-form-input"]}>
+                    <input type="password" name="Password" placeholder="Password" />
+                  </div>
+                  <div className={Login["login-page-body-container-body-form-button"]}>
+                    <input type="submit" value="Register Token" />
+                  </div>
+                </div>
+              </form>
+            </div>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+}
+registerLogin.isAuth = true;
+export default registerLogin;
--- a/NextDashboard/styles/Login.module.css
+++ b/NextDashboard/styles/Login.module.css
@ -0,0 +1,61 @@
+.login-page {
+  width: 360px;
+  padding: 8% 0 0;
+  margin: auto;
+}
+.login-page-container {
+  position: relative;
+  margin: auto;
+  width: 100%;
+  max-width: 360px;
+  text-align: center;
+}
+.login-page-header {
+  font-size: 20px;
+  font-weight: 300;
+  margin-bottom: 10px;
+}
+.login-page-body {
+  font-size: 13px;
+  font-weight: 400;
+  margin-bottom: 20px;
+}
+.login-page-body-container {
+  position: relative;
+  margin: auto;
+  width: 100%;
+  max-width: 360px;
+  text-align: center;
+}
+.login-page-body-container-header {
+  font-size: 20px;
+  font-weight: 300;
+  margin-bottom: 10px;
+}
+.login-page-body-container-body {
+  font-size: 13px;
+  font-weight: 400;
+  margin-bottom: 20px;
+}
+.login-page-body-container-body-form {
+  position: relative;
+  margin: auto;
+  width: 100%;
+  max-width: 360px;
+  text-align: center;
+}
+.login-page-body-container-body-form-input {
+  position: relative;
+  margin: auto;
+  width: 100%;
+  max-width: 360px;
+  text-align: center;
+}
+.login-page-body-container-body-form-button {
+  position: relative;
+  margin: auto;
+  width: 100%;
+  max-width: 360px;
+  text-align: center;
+  margin-top: 15px;
+}
--- a/NextDashboard/styles/global.css
+++ b/NextDashboard/styles/global.css
@ -0,0 +1 @@
+@import url("https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css");
--- a/dev.js
+++ b/dev.js
@ -1,3 +1,4 @@
 const { execSync } = require("child_process");
-execSync("docker-compose up --build -d", { stdio: "inherit" });
-execSync("docker logs --follow ofvp_server", { stdio: "inherit" });
+execSync("docker-compose up -d ofvp_mongodb", { stdio: "inherit" });
+execSync("docker-compose up --build -d ofvp_server", { stdio: "inherit" });
+execSync("docker logs --follow ofvp_server", { stdio: "inherit" });
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@ -20,12 +20,18 @@ services:
  ofvp_server:
    container_name: ofvp_server
    restart: on-failure
-    privileged: true
-    build: .
+    privileged: false
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: server
    depends_on:
      - ofvp_mongodb
    networks:
      - "ofvp_network"
+    environment:
+      NODE_ENV: "development"
+      MongoDB_URL: "mongodb://ofvp_mongodb:27017"
    ports:
      - 3000:3000/tcp
      - 80:80/tcp
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,11 +1,26 @@
 {
  "name": "@ofvp_project/server",
-  "version": "2.1.0",
+  "version": "2.5.0",
  "description": "",
  "main": "index.js",
  "scripts": {
-    "start": "docker-compose up --build -d",
-    "dev": "nodemon --watch ./src/ --watch Dockerfile --watch docker-compose.yaml -e js,json,html dev.js"
+    "start": "node src/index.js",
+    "start:sudo": "sudo -E node src/index.js",
+    "dev": "nodemon",
+    "next:build": "next build --debug NextDashboard/"
+  },
+  "nodemonConfig": {
+    "delay": 2500,
+    "exec": "node --trace-warnings dev.js",
+    "ext": "js,jsx,json,html,css",
+    "watch": [
+      "Dockerfile",
+      "docker-compose.yaml",
+      "src/",
+      "NextDashboard/",
+      "package.json",
+      "package-lock.json"
+    ]
  },
  "engines": {
    "node": ">=15.6.0"
@ -15,16 +30,21 @@
  "license": "MIT",
  "dependencies": {
    "body-parser": "^1.19.1",
+    "cli-color": "^2.0.1",
+    "connect-mongodb-session": "^3.1.1",
    "cors": "^2.8.5",
    "cron": "^1.8.2",
    "express": "^4.17.2",
-    "express-prettify": "^0.1.1",
    "express-rate-limit": "^6.2.0",
+    "express-session": "^1.17.2",
    "ip-matching": "^2.1.2",
    "js-yaml": "^4.1.0",
    "mongoose": "^6.1.8",
    "netmask": "^2.0.2",
+    "next": "^12.0.8",
    "qrcode": "^1.5.0",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
    "socket.io": "^4.4.1",
    "systeminformation": "github:sebhildebrandt/systeminformation"
  },
--- a/packages/Cli/package-lock.json
+++ b/packages/Cli/package-lock.json
@ -23,7 +23,7 @@
      "version": "2.1.0",
      "license": "MIT",
      "dependencies": {
-        "axios": "^0.24.0",
+        "axios": "^0.25.0",
        "cjs2esm": "^2.0.2",
        "socket.io-client": "^4.4.0"
      }
@ -719,7 +719,7 @@
    "@ofvp-project/client": {
      "version": "file:../Client",
      "requires": {
-        "axios": "^0.24.0",
+        "axios": "^0.25.0",
        "cjs2esm": "^2.0.2",
        "socket.io-client": "^4.4.0"
      }
--- a/src/Mongo/Connect.js
+++ b/src/Mongo/Connect.js
@ -1,16 +0,0 @@
-const { MongoDB_URL } = process.env;
-const mongoose = require("mongoose");
-const ServiceManeger = require("../lib/ServiceManeger/index");
-const PrintInfo = (...args) => ServiceManeger.PrintServices("Mongo", ...args);
-
-const Users = mongoose.createConnection(`${MongoDB_URL}/users`);
-Users.on("connected", () => PrintInfo("Sucess to connect to Users Database"));
-
-const AuthToken = mongoose.createConnection(`${MongoDB_URL}/token`);
-AuthToken.on("connected", () => PrintInfo("sucess to connect to Auth Token Database"));
-
-module.exports = {
-  UsersMongo: Users,
-  AuthTokenMongo: AuthToken,
-  Mongoose: mongoose
-};
--- a/src/Mongo/Schema.js
+++ b/src/Mongo/Schema.js
@ -1,129 +0,0 @@
-const { Mongoose, AuthTokenMongo, UsersMongo } = require("./Connect");
-const Crypto = require("crypto");
-
-// Token Schema
-const TokenSchema = new Mongoose.Schema({
-  // E-Mail Token
-  token: {
-    type: String,
-    required: true,
-    unique: true
-  },
-  // E-Mail
-  email: {
-    type: String,
-    required: true,
-    unique: true
-  },
-  // Password
-  password: {
-    type: String,
-    required: true
-  },
-  createdAt: {
-    type: Date,
-    default: Date.now
-  }
-});
-
-
-// Users Schema
-const AddUserSchema = new Mongoose.Schema({
-  // Username
-  username: {
-    type: String,
-    required: true,
-    unique: true
-  },
-  // SSH
-  expire: {
-    type: String,
-    required: true
-  },
-  ssh: {
-    password: {
-      type: String,
-      required: true
-    },
-    connections: {
-      type: Number,
-      required: true
-    }
-  },
-  v2ray: {
-    load: {
-      type: Boolean,
-      default: true
-    },
-    id: {
-      type: String,
-      default: Crypto.randomUUID,
-      required: true,
-      unique: true
-    },
-    level: {
-      type: Number,
-      default: 0
-    },
-    alterId: {
-      type: Number,
-      default: 0
-    }
-  },
-  // Wireguard Config
-  wireguard: {
-    load: {
-      type: Boolean,
-      default: true
-    },
-    keys: {
-      Preshared: {
-        type: String,
-        required: true,
-        unique: true
-      },
-      Private: {
-        type: String,
-        required: true,
-        unique: true
-      },
-      Public: {
-        type: String,
-        required: true,
-        unique: true
-      }
-    },
-    ip: {
-      v4: {
-        ip: {
-          type: String,
-          required: true,
-          unique: true
-        },
-        mask: {
-          type: String,
-          required: true
-        }
-      },
-      v6: {
-        ip: {
-          type: String,
-          required: true,
-          unique: true
-        },
-        mask: {
-          type: String,
-          required: true
-        }
-      }
-    }
-  }
-});
-
-// Exports
-module.exports = {
-  Token: {
-    AuthToken: AuthTokenMongo.model("AuthToken", TokenSchema)
-  },
-  Users: UsersMongo.model("Users", AddUserSchema)
-}
--- a/src/Users_Maneger.js
+++ b/src/Users_Maneger.js
@ -1,55 +1,106 @@
 const Wireguard = require("./services/wireguard/index");
 const Ssh = require("./services/ssh/index");
-const v2ray = require("./services/v2ray/Service");
-const MongoSchema = require("./Mongo/Schema");
-const { PrintServices } = require("./lib/ServiceManeger/index");
-const PrintConsole = (...Args) => PrintServices("User Maneger", ...Args);
+const OfvpMongo = require("./ofvp_mongo");
+const PasswordEncrypt = require("./lib/PasswordEncrypt");
+const Console = new (require("./lib/Console"))("User Maneger");
+const { CronJob } = require("cron");

 async function Load() {
  try {
    await Ssh.LoadUsers();
  } catch (err) {
-    PrintConsole("SSH not loaded users");
-    PrintConsole(err.stack);
+    Console.err("SSH not loaded users");
+    Console.err(err.stack);
  }
  try {
    await Wireguard.CreateServerConfig();
  } catch (err) {
-    PrintConsole("Wireguard not loaded");
-    PrintConsole(err.stack);
+    Console.err("Wireguard not loaded");
+    Console.err(err.stack);
  }
 }

-async function AddUser(Username = "", Password = "", Connections = 5, DateExpire = new Date((new Date()).getTime() * 2)) {
-  if (await MongoSchema.Users.findOne({ username: Username })) throw new Error("User already exists");
-  const Result = {
+/**
+ * 
+ * @param {{
+ *   Username: String;
+ *   Password: String;
+ *   Connections: number;
+ *   ExpireDate: String;
+ * }} UserBodyInfo 
+ * @returns {Promise<{
+ *   username: String;
+ *   expire: String
+ *   password: {
+ *     iv: String;
+ *     Encrypt: String;
+ *   };
+ *   ssh: {
+ *     connections: Number;
+ *   };
+ *   wireguard: {
+ *     load: Boolean;
+ *     keys: {
+ *       Preshared: String;
+ *       Private: String;
+ *       Public: String;
+ *     };
+ *     ip: {
+ *       v4: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *       v6: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *     }
+ *   }
+ *  }>}
+ */
+async function AddUser(UserBodyInfo = {}) {
+  if (await OfvpMongo.findOneUser(UserBodyInfo.Username)) throw new Error("User already exists");
+  UserBodyInfo.ExpireDate = new Date(UserBodyInfo.ExpireDate).toString();
+  const MongoUser = await OfvpMongo.AddUser({
    // Username
-    username: Username,
+    username: UserBodyInfo.Username,
    // SSH
-    expire: DateExpire.toString(),
+    expire: UserBodyInfo.ExpireDate,
+    password: PasswordEncrypt.EncryptPassword(UserBodyInfo.Password),
    ssh: {
-      password: Password,
-      connections: parseInt(Connections)
+      connections: parseInt(UserBodyInfo.Connections)
    },
    // Wireguard Config
    wireguard: await Wireguard.CreatePeerConfig()
-  };
-  const MongoUser = await MongoSchema.Users.create(Result);
-  await Ssh.AddtoSystem(Username, Password, DateExpire);
+  });
+  await Ssh.AddtoSystem(MongoUser.username, PasswordEncrypt.DecryptPassword(MongoUser.password.iv, MongoUser.password.Encrypt), new Date(MongoUser.expire));
  await Wireguard.CreateServerConfig();
-  v2ray.external_restart();
  return MongoUser;
 }

 async function RemoveUser(Username = "") {
  if (!Username) throw new Error("Username is empty");
-  const Res = {};
-  Res.ssh_system = await Ssh.RemoveFromSystem(Username);
-  Res.databade = await MongoSchema.Users.deleteOne({ username: Username });
+  await Ssh.RemoveFromSystem(Username);
+  await OfvpMongo.UsersSchema.deleteOne({ username: Username });
+  Console.log("Reloading Wireguard interface");
  await Wireguard.CreateServerConfig();
-  return Res;
+  return;
 }

+(new CronJob("*/1 * * * *", async function() {
+  for (const User of await OfvpMongo.GetUsers()) {
+    if ((new Date(User.expire)).getTime() <= (new Date).getTime()) {
+      Console.log("Ateaching user", User.username, "to remove");
+      try {
+        RemoveUser(User.username);
+      } catch (err) {
+        Console.err("Cannot remove", User.username);
+        Console.err(err);
+      }
+    }
+  }
+})).start();
+
 module.exports = {
  Load,
  AddUser,
--- a/src/api/index.js
+++ b/src/api/index.js
@ -1,24 +1,42 @@
 const http = require("http");
-const os = require("os");
-const Network = require("../ofvp_network");
 const express = require("express");
 const BodyParse = require("body-parser");
-const express_prettify = require("express-prettify");
 const cors = require("cors");
 const SocketIo = require("socket.io");
-const { ExpressCheckToken, createToken, CheckGetToken } = require("../auth");
-const Mongoose = require("../Mongo/Schema");
-const Package = require("../../package.json");
-const ServicesManeger = require("../lib/ServiceManeger/index");
-const MongooseConnect = require("../Mongo/Connect");
+const { CheckGetToken } = require("../auth");

 // Express App
 const app = express();
 app.use(cors());
 app.use(BodyParse.urlencoded({extended: true}));
 app.use(BodyParse.json());
-app.use(express_prettify({always: true, space: 2}));
+app.use((req, res, next) => {
+  res.json = (body) => {
+    if (!res.get("Content-Type")) {
+      res.set("Content-Type", "application/json");
+    }
+    res.send(JSON.stringify(body, (key, value) => typeof value === "bigint" ? value.toString() : value, 2));
+  }
+  return next();
+});

+const ExpressSession = require("express-session");
+const ExpressSessionDb = require("connect-mongodb-session")(ExpressSession);
+app.use(ExpressSession({
+  secret: process.env.COOKIE_SECRET || "BdsDash",
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    httpOnly: false,
+    maxAge: (1000 * 60 * 60 * 24 * 30 * 325),
+  },
+  store: new ExpressSessionDb({
+    uri: `${process.env.MongoDB_URL}/OFVpServer`,
+    collection: "CookieSessions"
+  })
+}));
+
+module.exports.app = app;
 function IsJson(JsonS = "{}") {
  try {
    JSON.parse(JsonS);
@ -28,8 +46,11 @@ function IsJson(JsonS = "{}") {
  }
 }

-// Socket.io
+// HTTP Server to Socket.io
 const Server = http.createServer(app);
+module.exports.Server = Server;
+
+// Socket.io
 const io = new SocketIo.Server(Server);
 io.use(async function (socket, next) {
  const { headers, query } = socket.handshake;
@ -50,96 +71,64 @@ io.use(async function (socket, next) {
  }
  return next(new Error("Token is not valid"));
 });
+module.exports.io = io;

-// Export
-module.exports = {
-  app: app,
-  Server: Server,
-  io: io
-};
-
-app.all(["/", "/info"], async (req, res) => {
-  const Cpus = os.cpus();
-  return res.json({
-    version: Package.version,
-    Nodejs_Version: process.version,
-    Services: ServicesManeger.GetOnlineServices(),
-    HostInfo: {
-      hostname: os.hostname(),
-      arch: os.arch(),
-      cpu: {
-        cores: Cpus.length,
-        Model: Cpus[0].model
+/**
+ * 
+ * @param {app} app 
+ * @param {String} ExtraPath 
+ * @returns 
+ */
+function GetRoutes(app, ExtraPath="") {
+  if (ExtraPath === undefined) ExtraPath = "";
+  if (ExtraPath === "undefined") ExtraPath = "";
+  const RoutesList = [];
+  for (const Route of [...(app.stack || app._router.stack)]) {
+    if (Route.route) {
+      if (Route.route.path && typeof Route.route.path === "string") {
+        if (Object.keys(Route.route.methods).length) {
+          for (const Methods of Object.keys(Route.route.methods)) {
+            RoutesList.push({
+              Method: Methods,
+              Path: `${ExtraPath}${Route.route.path}`
+            });
+          }
+        } else RoutesList.push({
+          Method: "?",
+          Path: `${ExtraPath}${Route.route.path}`
+        })
+      } else if (Route.route.paths && typeof Route.route.paths === "object") {
+        for (let Path of Route.route.paths) {
+          const MapE1 = {
+            Method: "?",
+            Path: `${ExtraPath}${Path}`
+          };
+          if (Object.keys(Route.route.methods).length) {
+            for (const method of Object.keys(Route.route.methods)) {
+              MapE1.Method = method;
+              RoutesList.push(MapE1);
+            }
+          } else RoutesList.push(MapE1);
+        }
+      } else if (Route.route.path && typeof Route.route.path === "object") {
+        for (let Path of Route.route.path) {
+          const MapE2 = {
+            Method: "?",
+            Path: `${ExtraPath}${Path}`
+          };
+          if (Object.keys(Route.route.methods).length) {
+            for (const method of Object.keys(Route.route.methods)) {
+              MapE2.Method = method;
+              RoutesList.push(MapE2);
+            }
+          } else RoutesList.push(MapE2);
+        }
      }
-    }
-  });
-});
-
-app.put("/v2/token", ExpressCheckToken, async (req, res) => {
-  const { Email = "", Password = "" } = req.body;
-  if (!Email) return res.status(400).json({error: "Email is required"});
-  if (!Password) return res.status(400).json({error: "Password is required"});
-  try {
-    const Data = await createToken(Email, Password);
-    return res.json(Data);
-  } catch (err) {
-    return res.status(400).json({error: String(err)});
+    } else if (Route.path && typeof Route.path === "string") RoutesList.push({
+      Method: "?",
+      Path: `${ExtraPath}${Route.path}`
+    });
  }
-});
-
-// Basic Services
-const Ssh = require("../services/ssh/index");
-const Wireguard = require("../services/wireguard/index");
-const UserManeger = require("../Users_Maneger");
-MongooseConnect.UsersMongo.on("connected", UserManeger.Load);
-
-app.get("/v2/user", ExpressCheckToken, async ({res}) => {
-  const Users = await Mongoose.Users.find();
-  return res.json(Users);
-});
-app.put("/v2/user", ExpressCheckToken, async (req, res) => {
-  const { Username, Password, Connections, ExpireDate } = req.body;
-  try {
-    return res.json(await UserManeger.AddUser(Username, Password, Connections, new Date(ExpireDate)));
-  } catch (err) {
-    return res.status(400).json({error: String(err)});
-  }
-});
-app.delete("/v2/user", ExpressCheckToken, async (req, res) => {
-  const { Username } = req.body;
-  try {
-    return res.send(await UserManeger.RemoveUser(Username));
-  } catch (err) {
-    return res.status(400).json({error: String(err), body: req.body});
-  }
-});
-
-// Wireguard Config
-app.get(["/v2/user/wireguard", "/v2/user/wireguard/:Type"], ExpressCheckToken, async (req, res) => {
-  const Type = (req.params.Type || "wireguard").toLowerCase();
-  const Username = req.query.Username;
-  if (!Username) return res.status(400).json({error: "Username is required"});
-  const UrlEnd = (req.query.host || req.headers.host || req.get("host") || req.originalUrl).replace(/:.*$/gi, "");
-  try {
-    if (Type === "json") return res.json(await Wireguard.CreateClientConfig(Username, Type, UrlEnd));
-    res.type("text/plain");
-    res.send(await Wireguard.CreateClientConfig(Username, Type, UrlEnd));
-  } catch (err) {
-    return res.status(400).json({error: String(err)});
-  }
-  return;
-});
-
-app.get("/v2/network/ssh_monitor", ExpressCheckToken, async ({res}) => {
-  const Data = await Ssh.SshMonitor();
-  return res.json(Data);
-});
-
-app.get("/v2/network", async ({res}) => {
-  const Stats = Network.GetNetworkStatics();
-  const Nload = Network.nload();
-  return res.json({
-    NetworkStats: Stats,
-    nload: Nload
-  });
-});
+  return RoutesList;
+}
+module.exports.GetExpressRoutes = GetRoutes;
--- a/src/api/routes/Dashboard.js
+++ b/src/api/routes/Dashboard.js
@ -0,0 +1,46 @@
+module.exports.ExpressPath = ["/Dashboard", "/Dashboard/*"];
+module.exports.ExpressReqType = "all";
+module.exports.isV2 = false;
+const express = require("express");
+const app = express.Router();
+module.exports.app = app;
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+app.use((req, res, next) => {
+  if (!(/\/Dashboard\/(_next|static)/i.test(req.path))) {
+    if (/\/([Ll]ogin|[Rr]egister)/i.test(req.path)) {
+      if ((req.session||{}).User) {
+        return res.redirect("/Dashboard");
+      }
+    } else if (!(req.session||{}).User) {
+      return res.redirect("/Dashboard/login?noLogged=true");
+    }
+  }
+  return next();
+});
+
+module.exports.waitStart = async () => {
+  const child_process = require("child_process");
+  const path = require("path");
+  const next = require("next");
+  const IsProduction = process.env.NODE_ENV === "production";
+  if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
+  if (IsProduction) {
+    try {
+      child_process.execFileSync("npm", ["run", "next:build"]);
+    } catch (err) {
+      const Errs = `\nStdout:\n${err.stdout.toString()} \n\nStderr:\n ${err.stderr.toString()}`;
+      console.error(Errs);
+      throw Errs;
+    }
+  }
+  const nextapp = next({
+    dev: !IsProduction,
+    dir: path.resolve(__dirname, "../../../NextDashboard"),
+    quiet: true,
+    conf: require("../../../NextDashboard/next.config")
+  });
+  await nextapp.prepare();
+  const NextReq = nextapp.getRequestHandler();
+  app.use((req, res) => NextReq(req, res));
+  console.log("Next Running");
+};
--- a/src/api/routes/Home.js
+++ b/src/api/routes/Home.js
@ -0,0 +1,25 @@
+const express = require("express");
+const app = express.Router();
+module.exports.app =app;
+module.exports.ExpressPath = false;
+const os = require("os");
+const ServicesManeger = require("../../lib/ServiceInit");
+const Package = require("../../../package.json");
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+
+app.get(["/info", "/"], async ({res}) => {
+  const Cpus = os.cpus();
+  return res.json({
+    version: Package.version,
+    Nodejs_Version: process.version,
+    Services: ServicesManeger.GetOnlineServices(),
+    HostInfo: {
+      hostname: os.hostname(),
+      arch: os.arch(),
+      cpu: {
+        cores: Cpus.length,
+        Model: Cpus[0].model
+      }
+    }
+  });
+});
--- a/src/api/routes/Network.js
+++ b/src/api/routes/Network.js
@ -0,0 +1,16 @@
+const express = require("express");
+const app = express.Router();
+module.exports.app = app;
+const { ExpressCheckToken } = require("../../auth");
+const Network = require("../../ofvp_network");
+const Ssh = require("../../services/ssh/index");
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+
+app.post("/reload/:Interface", ExpressCheckToken, async (req, res) => res.send(await Network.ReloadNetworkInterface(req.params.Interface)));
+app.get("/ssh_monitor", ExpressCheckToken, async ({res}) => res.json(await Ssh.SshMonitor()));
+app.get("/", async ({res}) => res.json({
+  NetworkStats: Network.GetNetworkStatics(),
+  nload: Network.nload()
+}));
+app.get("/Stats", ExpressCheckToken, async ({res}) => res.json(await Network.GetNetworkStatics()));
+app.get("/Nload", ExpressCheckToken, async ({res}) => res.json(await Network.nloadArray()));
--- a/src/api/routes/Services.js
+++ b/src/api/routes/Services.js
@ -0,0 +1,30 @@
+const express = require("express");
+const app = express.Router();
+module.exports.app = app;
+const UserAuth = require("../../auth");
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+const ServiceManeger = require("../../lib/ServiceInit");
+
+const getProcess = () => {
+  const Process = ServiceManeger.Process();
+  Object.keys(Process).forEach(key => delete Process[key].childProcess);
+  return Process;
+}
+app.get("/status/:ProcessUUID", UserAuth.ExpressCheckToken, async (req, res) => {
+  const { ProcessUUID } = req.params;
+  if (!ProcessUUID) return res.status(400).json({error: "ProcessUUID is required"});
+  try {
+    const ServiceStatus = (getProcess())[ProcessUUID];
+    return res.json(ServiceStatus);
+  } catch (err) {
+    return res.status(400).json({error: String(err.stack||err).split("\n")});
+  }
+});
+app.get("/status", UserAuth.ExpressCheckToken, async (req, res) => {
+  try {
+    const ServiceStatus = getProcess();
+    return res.json(ServiceStatus);
+  } catch (err) {
+    return res.status(400).json({error: String(err.stack||err).split("\n")});
+  }
+});
--- a/src/api/routes/TokenManeger.js
+++ b/src/api/routes/TokenManeger.js
@ -0,0 +1,53 @@
+const express = require("express");
+const app = express.Router();
+module.exports.app = app;
+const UserAuth = require("../../auth");
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+
+app.post("/token", UserAuth.ExpressCheckToken, async (req, res) => {
+  const RedirectPage = (req.query.redirect || "").replace(/\?.*/, "");
+  const { Email = "", Password = "" } = req.body;
+  if (!Email) return res.status(400).json({error: "Email is required"});
+  if (!Password) return res.status(400).json({error: "Password is required"});
+  try {
+    const TokenRegistred = await UserAuth.createToken(Email, Password);
+    if (!RedirectPage) return res.json(TokenRegistred);
+    res.redirect(RedirectPage+"?token=" + JSON.stringify(TokenRegistred));
+  } catch (err) {
+    if (!RedirectPage) return res.status(400).json({error: String(err.stack||err).split("\n")});
+    res.redirect(RedirectPage+`?Error=${encodeURIComponent(String(err.stack||err))}`);
+  }
+  return;
+});
+
+app.post("/CookieLogin", async (req, res) => {
+  const { Email, Password } = req.body;
+  const Redirect = (req.query.redirect || "").replace(/\?.*/, "");
+  var ConnectedStatus = false;
+  try {
+    if (await UserAuth.NewCheckToken(Email, Password)) {
+      req.session.User = `${Email}:AUTH:${Password}`;
+      await new Promise((resolve, reject) => req.session.save(err => {if(err) return reject(err);resolve()}));
+      ConnectedStatus = true;
+    }
+    res.set("AuthStatus", String(ConnectedStatus));
+    if (!Redirect) return res.sendStatus(200);
+    return res.redirect(`${Redirect}?AuthStatus=${ConnectedStatus}`);
+  } catch (err) {
+    if (!Redirect) return res.status(400).json({error: String(err.stack||err).split("\n")});
+    return res.redirect(`${Redirect}?Error=${encodeURIComponent(String(err.stack||err))}`);
+  }
+});
+
+app.post("/CookieLogout", async (req, res) => {
+  let Redirect = (req.query.redirect || "").replace(/\?.*/, "");
+  try {
+    await new Promise((resolve, reject) => req.session.destroy(err => {if(err) return reject(err);resolve()}));
+    if (!Redirect) return res.sendStatus(200);
+    return res.redirect(Redirect);
+  } catch (err) {
+    console.log(String(err.stack||err));
+    if (!Redirect) return res.sendStatus(400).send(String(err.stack||err));
+    return res.redirect(`${Redirect}?Error=${String(err.stack||err)}`);
+  }
+});
--- a/src/api/routes/Users.js
+++ b/src/api/routes/Users.js
@ -0,0 +1,64 @@
+const express = require("express");
+const app = express.Router();
+module.exports.app = app;
+const { ExpressCheckToken } = require("../../auth");
+const UserManeger = require("../../Users_Maneger");
+module.exports.listRoutes = () => (require("../index")).GetExpressRoutes(app);
+const OfvpMongo = require("../../ofvp_mongo");
+const Wireguard = require("../../services/wireguard/index");
+
+function parseToQuery(Objects = {}) {
+  let Query = [];
+  for (let key of Object.keys(Objects)) {
+    if (typeof Objects[key] === "string"||typeof Objects[key] === "number"||typeof Objects[key] === "boolean") Query.push(`${key}=${Objects[key]}`);
+    else if (Array.isArray(Objects[key])||typeof Objects[key] === "object") {
+      const sA = (parseToQuery(Objects[key])).map(a => `${key}_${a}`);
+      Query.push(...sA);
+    } else console.log(`${key} is not string or object`);
+  }
+  return Query;
+}
+
+
+app.get("/", ExpressCheckToken, async ({res}) => res.json(await OfvpMongo.GetUsers()));
+app.post("/", ExpressCheckToken, async (req, res) => {
+  const PageRedirect = (req.query.redirect||"").replace(/\?.*/gi, "");
+  try {
+    const UserData = await UserManeger.AddUser(req.body);
+    if (!PageRedirect) return res.json(UserData);
+    else {
+      const Querys = parseToQuery(UserData);
+      // console.log(Querys);
+      return res.redirect(PageRedirect + "?" + Querys.join("&"));
+    }
+  } catch (err) {
+    let erR = String(err.stack||err);
+    if (!PageRedirect)
+    return res.status(400).json({error: erR});
+    else res.redirect(PageRedirect + "?Error=" + erR);
+  }
+});
+app.delete("/", ExpressCheckToken, async (req, res) => {
+  const { Username } = req.body;
+  try {
+    return res.send(await UserManeger.RemoveUser(Username));
+  } catch (err) {
+    return res.status(400).json({error: String(err), body: req.body});
+  }
+});
+
+// Wireguard Config
+app.get(["/wireguard", "/wireguard/:Type"], ExpressCheckToken, async (req, res) => {
+  const Type = (req.params.Type || "wireguard").toLowerCase();
+  const Username = req.query.Username;
+  if (!Username) return res.status(400).json({error: "Username is required"});
+  const UrlEnd = (req.query.host || req.headers.host || req.get("host") || req.originalUrl).replace(/:.*$/gi, "");
+  try {
+    if (Type === "json") return res.json(await Wireguard.CreateClientConfig(Username, Type, UrlEnd));
+    res.type("text/plain");
+    res.send(await Wireguard.CreateClientConfig(Username, Type, UrlEnd));
+  } catch (err) {
+    return res.status(400).json({error: String(err)});
+  }
+  return;
+});
--- a/src/auth.js
+++ b/src/auth.js
@ -1,54 +1,88 @@
 const crypto = require("crypto");
-const { Token } = require("./Mongo/Schema");
+const { request, response } = require("express");
+const OfvpMongo = require("./ofvp_mongo");
+const { EncryptPassword, DecryptPassword } = require("./lib/PasswordEncrypt");

 async function createToken(Email = "", Password = "") {
  if (!Email) throw new Error("Email is required");
  if (!Password) throw new Error("Password is required");
  const RandomUid = crypto.randomUUID().split("-");
  const RandomToken = "Ofvp_"+RandomUid[0]+RandomUid[4];
-  // Mount Object
-  const TokenObject = {
+  return await OfvpMongo.AddToken({
    token: RandomToken,
    email: Email,
-    password: Password,
-  };
-  // Save Token
-  await Token.AuthToken.create(TokenObject);
+    password: EncryptPassword(Password),
+  });
+}
+
+/**
+ * Check Token exists and Return Object With Token and Emails (Includes password)
+ * 
+ * @param  {Array<String>} Args 
+ */
+async function CheckGetToken(...Args) {
+  if (!Args.length === 0) throw new Error("Token or Email and Password is required");
+  const ObjectFind = {};
+  if (Args.length === 2) {
+    ObjectFind.email = Args[0];
+    ObjectFind.password = Args[1];
+  } else ObjectFind.token = Args[0];
+  const TokenObject = (await OfvpMongo.GetTokens()).find(Token => {
+    if (ObjectFind.token) return Token.token === ObjectFind.token;
+    else {
+      if (ObjectFind.email && ObjectFind.password) return Token.email === ObjectFind.email && DecryptPassword(Token.password.iv, Token.password.Encrypt) === ObjectFind.password;
+      else return false;
+    }
+  });
+  if (!TokenObject) throw new Error("Token not found");
+  TokenObject.createdAt = new Date(TokenObject.createdAt);
  return TokenObject;
 }

-async function CheckGetToken(...Args) {
-  if (!Args.length === 0) throw new Error("Token or Email and Password is required");
-  let ObjectFind = {token: Args[0]};
-  if (Args.length === 2) {
-    ObjectFind = {
-      email: Args[0],
-      password: Args[1]
-    };
+/**
+ * Check Exists Token and Email and Return Boolean.
+ * 
+ * @param {String} TokenEmail 
+ * @param {String|undefined} Password 
+ * @returns {Boolean}
+ */
+async function booleanCheck(TokenEmail = "", Password = "") {
+  if (!TokenEmail) return false;
+  if (Password) {
+    if (!await CheckGetToken(TokenEmail, Password)) return false;
+  } else {
+    if (!await CheckGetToken(TokenEmail)) return false;
  }
-  const TokenObject = await Token.AuthToken.findOne(ObjectFind);
-  if (!TokenObject) throw new Error("Token not found");
-  return TokenObject;
+  return true;
 }

 async function deleteToken(...Args) {
-  if (!Args.length === 0) throw new Error("Token or Email and Password is required");
-  let ObjectFind = {token: Args[0]};
-  if (Args.length === 2) {
-    ObjectFind = {
-      email: Args[0],
-      password: Args[1]
-    };
-  }
-  const TokenObject = await Token.AuthToken.findOne(ObjectFind);
+  if (!Args.length === 0) throw new Error("Token or Email and or Password is required");
+  const ObjectFind = [];
+  if (Args.length === 2) ObjectFind.push(Args[0], Args[1]); else ObjectFind.push(Args[0]);
+  const TokenObject = await CheckGetToken(...ObjectFind);
  if (!TokenObject) throw new Error("Token not found");
-  await Token.AuthToken.deleteOne(TokenObject);
+  await OfvpMongo.AuthTokenSchema.deleteOne(TokenObject);
  return TokenObject;
 }

+/**
+ * Check is Auth or Token
+ * 
+ * @param {request} req 
+ * @param {response} res 
+ * @param {import("express").NextFunction} next 
+ * @returns 
+ */
 async function ExpressCheckToken(req, res, next) {
-  if ((await Token.AuthToken.find()).length === 0) {
-    if (/\/v.*\/token/gi.test(req.url)) return next();
+  if (req.session.User) {
+    const [Email, Password] = String(req.session.User).split(":AUTH:");
+    if (Email && Password) {
+      if (await booleanCheck(Email, Password)) return next();
+    }
+  }
+  if ((await OfvpMongo.AuthTokenSchema.find()).length === 0) {
+    if (req.path === "/token") return next();
    return res.status(401).json({
      error: "Register fist token"
    });
@ -91,5 +125,6 @@ module.exports = {
  createToken,
  CheckGetToken,
  deleteToken,
-  ExpressCheckToken
+  ExpressCheckToken,
+  NewCheckToken: booleanCheck
 };
--- a/src/config.js
+++ b/src/config.js
@ -13,6 +13,7 @@ if (!(fs.existsSync(MainStorage))) fs.mkdirSync(MainStorage, {recursive: true});
 if (!(fs.existsSync(SshKeysPath))) fs.mkdirSync(SshKeysPath, {recursive: true});

 let ServerConfig = {
+  secretKeyPa: Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
  Wireguard: {
    load_is_avaible: true,
    Interface: "wg0",
@ -25,12 +26,16 @@ let ServerConfig = {
 };

 const SaveConfig = () => {
-  console.log("\nNew Config Save:", ServerConfig, "\n");
+  if (fs.existsSync(ConfigPath)) console.log("\nNew Config Save:", ServerConfig, "\n");
  fs.writeFileSync(ConfigPath, JSON.stringify(ServerConfig, null, 2));
 }

 if (fs.existsSync(ConfigPath)) {
  ServerConfig = JSON.parse(fs.readFileSync(ConfigPath, "utf8"));
+  if (!ServerConfig.secretKeyPa) {
+    ServerConfig.secretKeyPa = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    SaveConfig();
+  }
 } else SaveConfig();

 module.exports = {
--- a/src/index.js
+++ b/src/index.js
@ -1,51 +1,97 @@
 const path = require("path");
+const fs = require("fs");
+fs.readdirSync(path.resolve(__dirname, "../")).forEach(file => {
+  if (/.*\.env/i.test(file)) {
+    if (file.endsWith(".json")||file.endsWith(".js")) {
+      const Env = require(path.resolve(__dirname, "../", file));
+      Object.keys(Env).forEach(key => {
+        process.env[key] = Env[key];
+      });
+    }
+  }
+});
 const { Server, app } = require("./api/index");
-const ServicesManeger = require("./lib/ServiceManeger/index");
+const ServicesManeger = require("./lib/ServiceInit");
+const UsersManeger = require("./Users_Maneger");
+const {isRegExp} = require("util/types");
+const Console = new (require("./lib/Console"))("OFVp Main Process");
+(async() => {
+  // Wait Mongo Database to be ready
+  Console.log("Waiting for MongoDB to be ready...");
+  await (require("./ofvp_mongo")).ConnectionStatus();
+  Console.log("MongoDB is ready!");

-// Load Services Process
-const PrintInfo = (...args) => ServicesManeger.PrintServices("OFVp API", ...args);
-ServicesManeger.LoadServicesRecursive(path.resolve(__dirname, "./services"));
+  // Wait to Load all Services Process available
+  await ServicesManeger.StartServices(true);

-// Listen Routes
-const MapedRoute = [...(app.stack || app._router.stack)].reduce((Routes, Route) => {
-  if (Route.route) {
-    if (Route.route.path && typeof Route.route.path === "string") {
-      if (Object.keys(Route.route.methods).length) {
-        Routes.push(`[${Object.keys(Route.route.methods)[0]}]: ${Route.route.path}`);
-      } else Routes.push(Route.route.path);
-    } else if (Route.route.paths && typeof Route.route.paths === "object") {
-      let Method = null;
-      if (Object.keys(Route.route.methods).length) Method = Object.keys(Route.route.methods)[0]
-      for (let Path of Route.route.paths) {
-        Routes.push(`[${Method ? Method : "?"}]: ${Path}`);
-      }
+  // Load Express Routes
+  Console.log("Loading Express Routes");
+  const MapRoutes = [];
+  for (const APIRoute of fs.readdirSync(path.join(__dirname, "./api/routes")).map(RoutePath => path.resolve(__dirname, "./api/routes", RoutePath))) {
+    const MidleMount = [];
+    const Middleware = require(APIRoute);
+    const BasenameRoute = "/v2"+APIRoute.replace(path.resolve(__dirname, "./api/routes"), "").replace(/\..*$/, "");
+    const DataMap = {
+      listRoutes: Middleware.listRoutes,
+      app: Middleware.app,
+      apiPath: APIRoute,
+      path: "",
+    };
+    if (typeof Middleware.waitStart === "function") await Middleware.waitStart();
+    if (Middleware.isV2 === undefined) Middleware.isV2 = true;
+    if (!(Middleware.ExpressPath === null||Middleware.ExpressPath === false)) {
+      if (Middleware.ExpressPath) {
+        if (typeof Middleware.ExpressPath === "string") DataMap.path = Middleware.ExpressPath;
+        else if (typeof Middleware.ExpressPath === "object") {
+          if (Array.isArray(Middleware.ExpressPath)) DataMap.path = Middleware.ExpressPath;
+          else DataMap.path = BasenameRoute;
+        } else if (isRegExp(Middleware.ExpressPath)) DataMap.path = Middleware.ExpressPath;
+      } else DataMap.path = BasenameRoute;
+      MidleMount.push(DataMap.path);
    }
-  } else if (Route.path && typeof Route.path === "string") Routes.push(Route.path);
-  return Routes;
-}, []);
-app.all("*", ({res}) => {
-  res.status(404).send({
-    error: "Not Found",
-    message: "The requested resource could not be found.",
-    paths: MapedRoute
+    Console.log(`Add Path to API:`, DataMap.path);
+    MidleMount.push(DataMap.app);
+    app[Middleware.ExpressReqType ? Middleware.ExpressReqType : "use"](...MidleMount);
+    MapRoutes.push(DataMap);
+  }
+  app.all("*", ({res}) => {
+    res.status(404).send({
+      error: "Not Found",
+      message: "The requested resource could not be found.",
+      paths: MapRoutes.map(a => {
+        return {
+          path: a.path,
+          endpoint: (a.listRoutes()).map(Route => {
+            if (typeof a.path === "object" && typeof a.path.map === "function") {
+              Route.Path = Array(a.path).map(Path => {
+                if (typeof Route === "object" && typeof Route.map === "function") return Route.map(Ro => Path+Ro);
+                else if (typeof Route === "object" && typeof Route.Path === "string") return Path+Route.Path;
+                else return Path+Route;
+              });
+            } else Route.Path = a.path+Route.Path;
+            return Route;
+          })
+        }
+      }).reduce((Old, At) => Old.concat(At.endpoint), [])
+    });
  });
-});
+  const ExpressPort = parseInt(process.env.PORT||3000);
+  Server.listen(ExpressPort, () => {
+    Console.log("Express listen in", ExpressPort);
+  });
+  Console.log("Express Routes Loaded");

-// Listen API
-const port = 3000;
-Server.listen(port, () => {
-  PrintInfo("Server is listening on port", port);
-});
+  // Load Users
+  Console.log("Loading Users");
+  await UsersManeger.Load();
+  Console.log("Users Loaded");

-if (process.argv.includes("--debug")) {
-  (async () => {
-    let IndexMS = 30 * 1000;
-    let NumberToRemove = 100;
-    while (IndexMS !== 0 && IndexMS > 0) {
-      PrintInfo(`Count Down to Exit: ${IndexMS}ms`);
-      IndexMS -= NumberToRemove;
-      await new Promise(resolve => setTimeout(resolve, NumberToRemove));
-    }
+  if (process.argv.includes("--debug")) {
+    await new Promise(resolve => setTimeout(resolve, 30 * 1000));
    process.exit(0);
-  })();
-}
+  }
+})().catch(Err => {
+  console.log("Backend Crash!\n\nError:\n");
+  console.log(Err);
+  process.exit(1);
+});
--- a/src/lib/Console.js
+++ b/src/lib/Console.js
@ -0,0 +1,31 @@
+const CliColor = require("cli-color");
+class Console {
+  constructor(AppPrint = "ANY") {
+    this.AppPrint = AppPrint;
+  }
+  log(...data) {
+    if (process.stdout.isTTY) {
+      console.log(CliColor.yellow(`[${this.AppPrint}]:\t`), ...data.map(Value => {
+        if (typeof Value === "string") return CliColor.blueBright(Value);
+        return Value;
+      }));
+    } else console.log(`[${this.AppPrint}]:\t`, ...data);
+  }
+  err(...data) {
+    if (process.stdout.isTTY) {
+      console.log(CliColor.red(`[${this.AppPrint}] 🐞:\t`), ...data.map(Value => {
+        if (typeof Value === "string") return CliColor.redBright(Value);
+        return Value;
+      }));
+    } else console.log(`[${this.AppPrint}]:\t`, ...data);
+  }
+  warn(...data) {
+    if (process.stdout.isTTY) {
+      console.log(CliColor.yellow(`[${this.AppPrint}]:\t`), ...data.map(Value => {
+        if (typeof Value === "string") return CliColor.yellowBright(Value);
+        return Value;
+      }));
+    } else console.log(`[${this.AppPrint}]:\t`, ...data);
+  }
+}
+module.exports = Console;
--- a/src/lib/PasswordEncrypt.js
+++ b/src/lib/PasswordEncrypt.js
@ -0,0 +1,21 @@
+const Config = require("../config");
+const crypto = require("crypto");
+const algorithm = "aes-192-cbc";
+
+module.exports.EncryptPassword = EncryptPassword;
+function EncryptPassword(Password = "") {
+  const iv = crypto.randomBytes(16);
+  const key = crypto.scryptSync((Config.GetConfig()).secretKeyPa, "salt", 24);
+  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  return {
+    iv: iv.toString("hex"),
+    Encrypt: cipher.update(Password, "utf8", "hex") + cipher.final("hex")
+  }
+};
+
+module.exports.DecryptPassword = DecryptPassword;
+function DecryptPassword(iv = "", PasswordEncrypt="") {
+  const key = crypto.scryptSync((Config.GetConfig()).secretKeyPa, "salt", 24);
+  const decipher = crypto.createDecipheriv(algorithm, key, Buffer.from(iv, "hex"));
+  return decipher.update(PasswordEncrypt, "hex", "utf8") + decipher.final("utf8");
+};
--- a/src/lib/ServiceInit.js
+++ b/src/lib/ServiceInit.js
@ -0,0 +1,125 @@
+const child_process = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const Console = new (require("./Console"))("Service Init");
+const crypto = require("crypto");
+
+/**
+ * @type {Object<string,{
+ *   name: String;
+ *   Oldlog: Array<{std: "err"|"out"|"info";data: string}>;
+ *   log: Array<{std: "err"|"out"|"info";data: string}>;
+ *   Reunning: Boolean;
+ *   autoRestart: Boolean;
+ *   childProcess: child_process.ChildProcess;
+ *   Start: () => Promise<child_process.ChildProcess>;
+ * }>}
+ */
+const ProcessListeners = {};
+module.exports.ProcessListeners = () => Object.keys(ProcessListeners).map(key => ProcessListeners[key]);
+module.exports.Process = () => ProcessListeners;
+module.exports.GetOnlineServices = () => Object.keys(ProcessListeners).map(key => ProcessListeners[key]).reduce((a, b) => {if (b.Reunning) a.Running.push(b.name);else a.Offline.push(b.name);return a;}, {Running: [], Offline: []});
+
+/**
+ * 
+ * @param {String} Dir 
+ * @returns {Array<{
+ *   Service: {
+ *    name: String|undefined;
+ *    isChildProcess: Boolean;
+ *    manualChildProcess: Boolean;
+ *    autoRestart: Boolean;
+ *    start: () => Promise<child_process.ChildProcess>;
+ *   };
+ *   Path: String;
+ * }>}
+ */
+const ServicersFolder = (Dir="") => {
+  const Dirs = fs.readdirSync(path.resolve(Dir));
+  const ServicesFiles = [];
+  for (const DirF of Dirs) {
+    const Path = path.resolve(Dir, DirF);
+    if (fs.lstatSync(Path).isDirectory()) {
+      ServicesFiles.push(...ServicersFolder(Path));
+    } else if (/Services_|Service\.js/i.test(Path)) {
+      ServicesFiles.push({
+        Path: Path,
+        Service: require(Path)
+      });
+    }
+  }
+  return ServicesFiles;
+}
+
+async function Mount() {
+  const ServiceFolder = ServicersFolder(path.resolve(__dirname, "../services"));
+  for (const { Service: __ServiceConfig, Path: __Service} of ServiceFolder) {
+    const ServiceUUID = crypto.randomUUID();
+    let ServiceName = "";
+    if (/Services_/i.test(__Service)) ServiceName = path.parse(__Service).name.replace("Services_", ""); else ServiceName = path.basename(path.parse(__Service).dir);
+    if (__ServiceConfig.name) ServiceName = __ServiceConfig.name;
+    ProcessListeners[ServiceUUID] = {
+      name: ServiceName,
+      log: [],
+      Oldlog: [],
+      Reunning: false,
+      autoRestart: false,
+      childProcess: null,
+      Start: () => {}
+    };
+    if (__ServiceConfig.isChildProcess||__ServiceConfig.IsChildProcess) {
+      /**
+       * Write Logs
+       * @param {String} Std 
+       * @param  {Array<String>} Data 
+       */
+      const SaveLog = (Std = "out", ...Data) => {
+        ProcessListeners[ServiceUUID].log.push({
+          std: Std,
+          data: String(Data.join(" "))
+        });
+      }
+      let CountRestart = -1;
+      const Re_StartProcess = async () => {
+        Console.log("Starting Service:", ServiceName);
+        if (ProcessListeners[ServiceUUID].log.length !== 0) {
+          ProcessListeners[ServiceUUID].Oldlog.push(...ProcessListeners[ServiceUUID].log);
+          ProcessListeners[ServiceUUID].log = [];
+        }
+        const ChildProcess = await __ServiceConfig.start(SaveLog);
+        ProcessListeners[ServiceUUID].childProcess = ChildProcess;
+        ProcessListeners[ServiceUUID].Reunning = true;
+        ProcessListeners[ServiceUUID].autoRestart = (__ServiceConfig.autoRestart||__ServiceConfig.AutoRestart)
+        ChildProcess.stdout.on("data", data => SaveLog("out", data));
+        ChildProcess.stderr.on("data", data => SaveLog("err", data));
+        process.on("exit", () => {Console.log("Killing Service:", ServiceName);if (ProcessListeners[ServiceUUID].Reunning) ChildProcess.kill("SIGKILL");});
+        ChildProcess.on("exit", async code => {
+          ProcessListeners[ServiceUUID].Reunning = false;
+          SaveLog("info", "exit with code:", code);
+          if ((__ServiceConfig.autoRestart||__ServiceConfig.AutoRestart)) {
+            CountRestart++;
+            if (CountRestart > 3) {
+              SaveLog("info", "No restart, limit to restart");
+              Console.err("No restart, limit to restart, more info acess log with endpoints:", "/v2/Services/status/"+ServiceUUID);
+            }
+            else Re_StartProcess();
+          }
+          return;
+        });
+      }
+      ProcessListeners[ServiceUUID].Start = Re_StartProcess;
+    } else Console.warn("Service:", ServiceName, "is not child process");
+  }
+}
+
+async function StartServices(LockProcess = false) {
+  await Mount();
+  if (LockProcess) {
+    for (let process of Object.keys(ProcessListeners)) await ProcessListeners[process].Start();
+  } else Object.keys(ProcessListeners).forEach(key => ProcessListeners[key].Start());
+  return;
+}
+module.exports.StartServices = StartServices;
+if (require.main === module) {
+  StartServices();
+}
--- a/src/lib/ServiceManeger/index.js
+++ b/src/lib/ServiceManeger/index.js
@ -1,103 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-const GlobalLog = {};
-const Services = {};
-
-class RegisterLog {
-  LogRegisterInArray (...Logs) {
-    for (let Log of Logs) {
-      if (typeof Log === "string") {
-        for (let line of Log.split("\n")) {
-          if (!GlobalLog[this.Name]) GlobalLog[this.Name] = [];
-          GlobalLog[this.Name].push(`[${this.Name}]: \t${line}`);
-        }
-      }
-    }
-  }
-  constructor (ServiceName = "") {
-    if (!ServiceName) throw new Error("Requires name of service");
-    this.Name = ServiceName;
-    GlobalLog[this.Name] = [];
-    return this;
-  }
-}
-
-function LoadServicesRecursive(RootPage = path.resolve(__dirname, "../../services")) {
-  const ServiceList = fs.readdirSync(RootPage).map(file => {
-    if (fs.existsSync(path.resolve(RootPage, file, "Service.js")) && fs.statSync(path.resolve(RootPage, file, "Service.js")).isFile()) {
-      return {
-        path: path.resolve(RootPage, file, "Service.js"),
-        Dir: file,
-        CwdFolder: path.resolve(RootPage, file)
-      };
-    } else if (file.startsWith("Services_") && file.endsWith(".js")) {
-      return {
-        path: path.resolve(RootPage, file),
-        Dir: path.parse(file).name.replace("Services_", ""),
-        CwdFolder: RootPage
-      }
-    } else return null;
-  }).filter(file => file !== null);
-  for (const Service of ServiceList) {
-    try {
-      let NameModule = Service.Dir;
-      let RestartOnExit = false;
-      const ServiceModule = require(Service.path);
-      if (ServiceModule.name) NameModule = ServiceModule.name;
-      if (ServiceModule.AutoRestart) RestartOnExit = ServiceModule.AutoRestart;
-      console.log(`[Services]: \tLoading service ${NameModule}`);
-      const CreateLog = new RegisterLog(NameModule);
-      if (typeof ServiceModule.start === "function") {
-        const StartService = async () => {
-          const Stated = await ServiceModule.start();
-          if (!Services[NameModule]) {
-            Services[NameModule] = {
-              Running: true,
-              pid: Stated.pid
-            };
-          } else Services[NameModule].Running = true;
-          if (ServiceModule.IsChildProcess) {
-            Stated.stdout.on("data", CreateLog.LogRegisterInArray);
-            Stated.stderr.on("data", CreateLog.LogRegisterInArray);
-            Stated.on("exit", async CodeExit => {
-              Services[NameModule].Running = false;
-              console.log(`[Services]: \tService ${NameModule} exited with code ${CodeExit}`);
-              console.log((GlobalLog[NameModule] || []).join("\n"));
-              GlobalLog[NameModule] = [];
-              if (RestartOnExit) StartService();
-            });
-          }
-        }
-        // Fist Init
-        StartService();
-      }
-    } catch (err) {
-      let LogError = [
-        `[${Service.Dir}]: \tCan't load service`,
-        `[${Service.Dir}]: \t${String(err)}`,
-        `[${Service.Dir}]: \t${err.stack.split("\n").join(`\n[${Service.Dir}]: \t`)}`,
-        "",
-        `Service Path: ${Service.path}`,
-        "",
-      ];
-      console.log(LogError.join("\n"));
-      if (!GlobalLog[Service.Dir]) GlobalLog[Service.Dir] = LogError;
-      else GlobalLog[Service.Dir].push("ERROR", "ERROR", "ERROR", "ERROR", ...LogError, "ERROR", "ERROR", "ERROR", "ERROR");
-    }
-  }
-  return ServiceList;
-}
-
-module.exports = {
-  LoadServicesRecursive,
-  GetOnlineServices: () => Object.keys(Services).reduce((acc, key) => {
-    if (Services[key].Running) acc.Running.push(key);
-    else acc.Offline.push(key);
-    return acc;
-  }, {Running: [], Offline: []}),
-  PrintServices: (ServicesName = "", ...Logs) => {
-    a = Logs.join(" ").split("\n").join(`\n[${ServicesName}]: \t`);
-    console.log(`[${ServicesName}]: \t${a}`);
-  },
-  GetLogs: () => GlobalLog
-};
--- a/src/ofvp_mongo.js
+++ b/src/ofvp_mongo.js
@ -0,0 +1,279 @@
+const { MongoDB_URL } = process.env;
+if (!(/(mongodb|mongodb\+srv):\/\/([a-zA-Z0-9@:]+)[a-zA-Z0-9\.]+/gi.test(MongoDB_URL) && !/:[a-zA-Z]+$/gi.test(MongoDB_URL))) throw new Error("Invalid MongoDB URL: "+MongoDB_URL);
+const Mongoose = require("mongoose");
+const Console = new (require("./lib/Console"))("Mongo");
+const { EncryptPassword, DecryptPassword } = require("./lib/PasswordEncrypt");
+const ConnectionStatusObject = {Status: "Connecting", Error: null};
+const Connection = Mongoose.createConnection(`${MongoDB_URL}/OFVpServer`);
+Connection.on("connected", () => {
+  ConnectionStatusObject.Status = "Connected";
+  ConnectionStatusObject.Error = null;
+});
+Connection.on("error", err => {
+  ConnectionStatusObject.Status = "Error";
+  ConnectionStatusObject.Error = err;
+  Console.err("Error to connect in MongoDB", err);
+});
+/**
+ * Get Users Database Connection Status
+ * @returns {Promise<ConnectionStatusObject>}
+ */
+module.exports.ConnectionStatus = async () => {
+  while (true) {
+    if (ConnectionStatusObject.Status === "Connected") return ConnectionStatusObject;
+    if (ConnectionStatusObject.Status === "Error") {
+      const Err = new Error("Users MongoDB Error in Connection");
+      Err.RAW = ConnectionStatusObject.Error;
+      throw Err;
+    }
+    if (ConnectionStatusObject.Status !== "Connecting") throw new Error("Users MongoDB Error in Connection");
+    await new Promise(res => setTimeout(res, 1000));
+  }
+}
+
+// Token Schema
+const TokenSchema = new Mongoose.Schema({
+  // E-Mail Token
+  token: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  // E-Mail
+  email: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  // Password
+  password: {
+    iv: {
+      type: String,
+      required: true
+    },
+    Encrypt: {
+      type: String,
+      required: true
+    }
+  },
+  createdAt: {
+    type: String,
+    default: () => (new Date).toString()
+  }
+});
+
+// Users Schema
+const AddUserSchema = new Mongoose.Schema({
+  // Username
+  username: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  // SSH
+  expire: {
+    type: String,
+    required: true
+  },
+  password: {
+    iv: {
+      type: String,
+      required: true
+    },
+    Encrypt: {
+      type: String,
+      required: true
+    }
+  },
+  ssh: {
+    connections: {
+      type: Number,
+      required: true
+    }
+  },
+  // Wireguard Config
+  wireguard: {
+    load: {
+      type: Boolean,
+      default: true
+    },
+    keys: {
+      Preshared: {
+        type: String,
+        required: true,
+        unique: true
+      },
+      Private: {
+        type: String,
+        required: true,
+        unique: true
+      },
+      Public: {
+        type: String,
+        required: true,
+        unique: true
+      }
+    },
+    ip: {
+      v4: {
+        ip: {
+          type: String,
+          required: true,
+          unique: true
+        },
+        mask: {
+          type: String,
+          required: true
+        }
+      },
+      v6: {
+        ip: {
+          type: String,
+          required: true,
+          unique: true
+        },
+        mask: {
+          type: String,
+          required: true
+        }
+      }
+    }
+  }
+});
+
+// Exports Schema
+const UsersSchema = Connection.model("Users", AddUserSchema);
+module.exports.UsersSchema = UsersSchema;
+
+const AuthTokenSchema = Connection.model("AuthToken", TokenSchema);
+module.exports.AuthTokenSchema = AuthTokenSchema;
+
+/**
+ * Get Array users config
+ * 
+* @returns {Promise<Array<{
+  *   username: String;
+  *   expire: String
+  *   password: {
+  *     iv: String;
+  *     Encrypt: String;
+  *   };
+  *   ssh: {
+  *     connections: Number;
+  *   };
+  *   wireguard: {
+  *     load: Boolean;
+  *     keys: {
+  *       Preshared: String;
+  *       Private: String;
+  *       Public: String;
+  *     };
+  *     ip: {
+  *       v4: {
+  *         ip: String;
+  *         mask: String;
+  *       };
+  *       v6: {
+  *         ip: String;
+  *         mask: String;
+  *       };
+  *     }
+  *   }
+  *  }>>}
+  */
+module.exports.GetUsers = async () => await UsersSchema.find({});
+
+/**
+ * 
+ * @param {{
+ *   username: String;
+ *   expire: String
+ *   password: {
+ *     iv: String;
+ *     Encrypt: String;
+ *   };
+ *   ssh: {
+ *     connections: Number;
+ *   };
+ *   wireguard: {
+ *     load: Boolean;
+ *     keys: {
+ *       Preshared: String;
+ *       Private: String;
+ *       Public: String;
+ *     };
+ *     ip: {
+ *       v4: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *       v6: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *     }
+ *   }
+ * }} BodyRecive 
+ * @returns {Promise<BodyRecive>}
+ */
+module.exports.AddUser = async (BodyRecive) => {await UsersSchema.create(BodyRecive);return BodyRecive;};
+
+/**
+ * 
+ * @param {String} username 
+ * @returns {Promise<{
+ *   username: String;
+ *   expire: String
+ *   password: {
+ *     iv: String;
+ *     Encrypt: String;
+ *   };
+ *   ssh: {
+ *     connections: Number;
+ *   };
+ *   wireguard: {
+ *     load: Boolean;
+ *     keys: {
+ *       Preshared: String;
+ *       Private: String;
+ *       Public: String;
+ *     };
+ *     ip: {
+ *       v4: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *       v6: {
+ *         ip: String;
+ *         mask: String;
+ *       };
+ *     }
+ *  }
+ * }|undefined>}
+ */
+module.exports.findOneUser = async (username) => await UsersSchema.findOne({username: username});
+
+/**
+ * 
+ * @returns {Promise<Array<{
+ *   token: String;
+ *   email: String;
+ *   password: {
+ *     iv: String;
+ *     Encrypt: String;
+ *   };
+ *   createdAt: String;
+ * }>>}
+ */
+module.exports.GetTokens = async () => await AuthTokenSchema.find({});
+
+/**
+ * 
+ * @param {{
+ *  token: String;
+ *  email: String;
+ *  password: String;
+ * }} BodyRecive 
+ * @returns {Promise<BodyRecive>}
+ */
+module.exports.AddToken = async (BodyRecive) => {await AuthTokenSchema.create(BodyRecive); return BodyRecive};
--- a/src/ofvp_network.js
+++ b/src/ofvp_network.js
@ -1,6 +1,7 @@
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
+const child_process = require("child_process");

 function LocalInterfaces() {
  const interfaces = os.networkInterfaces();
@ -36,6 +37,7 @@ function LocalInterfaces() {
  }
  return localInterfaces;
 }
+module.exports.LocalInterfaces = LocalInterfaces;

 function FixUnites (Bytes = 0, IsNload = false) {
  const Units = [];
@ -87,31 +89,50 @@ function GetNetworkStatics() {
  // ---------------
  return interfaces;
 }
+module.exports.GetNetworkStatics = GetNetworkStatics;

 // nload on Javascript
-let dataFrameOld = {};
-function nload() {
+/**
+ * @type {Object<string,{
+ *   rxBytes: {value: Number; unit: string;};
+ *   txBytes: {value: Number; unit: string;};
+ * }>}
+ */
+let nloadStorage = {};
+const OldBytes = {};
+module.exports.nload = () => nloadStorage;
+module.exports.nloadArray = () => {const Lo = nloadStorage;return Object.keys(Lo).map(NameInterface => {return {interface: NameInterface, ...Lo[NameInterface]};})};
+setInterval(async () => {
  const dataFrame = {};
-  for (let iface of GetNetworkStatics()) {
-    if (!dataFrameOld[iface.interfaceName]) dataFrameOld[iface.interfaceName] = {rxBytes: 0, txBytes: 0};
-    dataFrame[iface.interfaceName] = {
-      rxBytes: FixUnites(Math.floor((iface.rxBytes - dataFrameOld[iface.interfaceName].rxBytes) * 8), true),
-      txBytes: FixUnites(Math.floor((iface.txBytes - dataFrameOld[iface.interfaceName].txBytes) * 8), true)
+  for (let { interfaceName, rxBytes, txBytes } of GetNetworkStatics()) {
+    const { oldRx = 0, oldTx = 0 } = OldBytes[interfaceName]||{};
+    OldBytes[interfaceName] = {oldRx: rxBytes, oldTx: txBytes};
+    const DataTointerface = {
+      rxBytes: FixUnites(Math.floor((rxBytes - oldRx) * 8), true),
+      txBytes: FixUnites(Math.floor((txBytes - oldTx) * 8), true)
    };
+    dataFrame[interfaceName] = DataTointerface;
  }
-  return dataFrame;
-}
-setInterval(() => {
-  for (let iface of GetNetworkStatics()) {
-    dataFrameOld[iface.interfaceName] = {
-      rxBytes: iface.rxBytes,
-      txBytes: iface.txBytes
-    };
-  }
-}, 800);
+  nloadStorage = dataFrame;
+}, 760);

-module.exports = {
-  LocalInterfaces,
-  GetNetworkStatics,
-  nload
-};
+/**
+ * Reload network interface
+ * 
+ * @param {String} Interface 
+ * @returns {Promise<String>}
+ */
+async function ReloadNetworkInterface(Interface = "eth0") {
+  try {
+    child_process.execFileSync("ip", ["link", "set", Interface, "down"]);
+  } catch (err) {
+    throw new Error("Connot set interface down");
+  }
+  try {
+    child_process.execFileSync("ip", ["link", "set", Interface, "up"]);
+  } catch (err) {
+    throw new Error("Connot set interface up");
+  }
+  return os.networkInterfaces()[Interface][0].address;
+}
+module.exports.ReloadNetworkInterface = ReloadNetworkInterface;
--- a/src/services/ssh/Service.js
+++ b/src/services/ssh/Service.js
@ -1,28 +1,31 @@
-const ServiceName = "SSH Server";
-let LoaddedKeys = false;
-const RandonPassword = Math.random().toString(36).substring(2, 15).slice(-8);
-
+module.exports.name = "SSH Server";
+module.exports.isChildProcess = true;
+module.exports.autoRestart = true;
+module.exports.waitProcess = true;
 const child_process = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const ConfigAndPaths = require("../../config");
-const Moongose = require("../../Mongo/Connect");
 const sshIndex = require("./index");
-const { PrintServices } = require("../../lib/ServiceManeger/index");
-
-PrintLog = (...args) => PrintServices(ServiceName, ...args);
-Moongose.UsersMongo.on("connected", sshIndex.LoadUsers);
+const Console = new (require("../../lib/Console"))("SSH Service");

 // Change Root Password
-try {
-  child_process.execSync(`(echo ${RandonPassword};echo ${RandonPassword}) | passwd root`, {stdio: "pipe"});
-  PrintLog("Root Password Changed to", RandonPassword);
-} catch (e) {
-  PrintLog("Root Password Change Failed");
-  PrintLog(e);
-}
+const RandonPassword = Math.random().toString(36).substring(2, 15).slice(-8);
+child_process.exec(`(echo ${RandonPassword};echo ${RandonPassword}) | passwd root`, (err) => {
+  if (err) {
+    Console.err("Failed To Change Root Password");
+    Console.err(err);
+    return;
+  }
+  Console.log("Root Password Changed to", RandonPassword);
+});

-function StartSshd () {
+const Loaddeds = {
+  Keys: false,
+  Users: false
+};
+async function StartSshd () {
+  if (!(fs.existsSync("/run/sshd"))) fs.mkdirSync("/run/sshd");
  const SSHConfigArray = [
    "PasswordAuthentication yes",
    "PermitRootLogin yes",
@ -30,7 +33,7 @@ function StartSshd () {
    "Include /etc/ssh/sshd_config.d/*.conf",
    "UsePAM yes",
    "X11Forwarding no",
-    "PrintMotd no",
+    "PrintMotd yes",
    "AcceptEnv LANG LC_*",
    "Subsystem       sftp    /usr/lib/openssh/sftp-server",
    `Banner ${path.resolve(__dirname, "./banner.html")}`,
@ -44,28 +47,22 @@ function StartSshd () {
  fs.writeFileSync("/etc/ssh/sshd_config", SSHConfigArray.join("\n"));

  // Copy or Create ssh host keys
-  if (!LoaddedKeys) {
+  if (!Loaddeds.Keys) {
    if (fs.readdirSync(ConfigAndPaths.ssh.SshKeysPath).filter(file => file.includes("ssh_host_")).length === 0) {
-      PrintLog("SSH Host Keys Found, Creating New Keys");
+      Console.log("SSH Host Keys Found, Creating New Keys");
      child_process.execSync("dpkg-reconfigure openssh-server &> /dev/null");
      fs.readdirSync("/etc/ssh").filter(file => file.includes("ssh_host_")).map(KeyFile => path.join("/etc/ssh/", KeyFile)).forEach(KeyFile => fs.copyFileSync(KeyFile, path.join(ConfigAndPaths.ssh.SshKeysPath, path.basename(KeyFile))));
    } else {
-      PrintLog("Copying SSH Host Keys");
+      Console.log("Copying SSH Host Keys");
      fs.readdirSync(ConfigAndPaths.ssh.SshKeysPath).filter(Key => Key.includes("ssh_host_")).map(Key => path.join(ConfigAndPaths.ssh.SshKeysPath, Key)).forEach(KeyFile => {
        const KeyFileOut = path.join("/etc/ssh", path.basename(KeyFile));
        fs.copyFileSync(KeyFile, KeyFileOut);
        child_process.execFileSync("chmod", ["0600", "-v", KeyFileOut], {stdio: "ignore"});
      });
    }
-    LoaddedKeys = true;
+    Loaddeds.Keys = true;
  }
-  if (!(fs.existsSync("/run/sshd"))) fs.mkdirSync("/run/sshd");
-  return child_process.exec("/usr/sbin/sshd -D -f /etc/ssh/sshd_config");
+  return child_process.exec("/usr/sbin/sshd -D -d -f /etc/ssh/sshd_config");
 }
+module.exports.start = StartSshd;

-module.exports = {
-  IsChildProcess: true,
-  AutoRestart: true,
-  name: ServiceName,
-  start: StartSshd,
-};
--- a/src/services/ssh/index.js
+++ b/src/services/ssh/index.js
@ -1,40 +1,81 @@
 const child_process = require("child_process");
-const fs = require("fs");
 const Process = require("../../ofvp_process");
-const Moongose = require("../../Mongo/Schema");
+const OfvpMongo = require("../../ofvp_mongo");
+const PasswordEncrypt = require("../../lib/PasswordEncrypt");
 const { CronJob } = require("cron");
-const { PrintServices } = require("../../lib/ServiceManeger/index");
-PrintLog = (...args) => PrintServices("SSH Main", ...args);
+const Console = new (require("../../lib/Console"))("SSH");

-function AddtoSystem(username = "", password = "", ExpireDate = new Date(Date.now() * 2)) {
-  if (typeof username !== "string") throw (new Error("the user must be a string"));
-  if (typeof password !== "string") throw (new Error("the passworld must be a string"));
-  if (username.length <= 2 || username.length >= 30) throw (new Error("Username Short or long"));
-  if (password.length <= 4) throw (new Error("Password is too short"));
-  const PerlPass = child_process.execSync(`perl -e 'print crypt($ARGV[0], "password")' ${password}`, {stdio: "pipe"}).toString();
+/**
+ * 
+ * @param {string} cmd 
+ * @param {*} args 
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+const execPromise = (cmd, options) => new Promise((resolve, reject) => {
+  child_process.exec(cmd, options, (err, stdout, stderr) => {
+    if (err) return reject(err);
+    return resolve({stdout, stderr});
+  });
+});
+/**
+ * 
+ * @param {string} cmd 
+ * @param {Array<string>} args 
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+const execFilePromise = (cmd, args) => new Promise((resolve, reject) => {
+  child_process.execFile(cmd, args, (err, stdout, stderr) => {
+    if (err) return reject(err);
+    return resolve({stdout, stderr});
+  });
+});

-  let day = ExpireDate.getDate().toString(), mounth = (ExpireDate.getMonth() + 1).toString();
-  if (ExpireDate.getDate() <= 9) day = `0${ExpireDate.getDate()}`;
-  if ((ExpireDate.getMonth() + 1) <= 9) mounth = `0${(ExpireDate.getMonth() + 1).toString()}`;
-  const DateToExpire = `${ExpireDate.getFullYear()}-${mounth}-${day}`;
-  child_process.execFileSync("useradd", ["-e", DateToExpire, "-M", "-s", "/bin/false", "-p", PerlPass, username], {stdio: "pipe"});
-  return {
-    Username: username,
-    Password: password,
-    ExpireDate: ExpireDate
+/**
+ * 
+ * @param {string} username 
+ * @param {string} password 
+ * @param {Date} ExpireDate 
+ * @returns {Promise<{
+ *   Add: true|false;
+ *   Error: null|Array<string>|string;
+ * }>}
+ */
+async function AddtoSystem(username = "", password = "", ExpireDate = new Date(Date.now() * 2)) {
+  if (username.length <= 4) return {
+    Add: false,
+    Error: "Username must be at least 5 characters"
  };
+  if (username.length >= 30) return {
+    Add: false,
+    Error: "Username must be less than 30 characters"
+  };
+  if (password.length <= 4) return {
+    Add: false,
+    Error: "Password must be at least 5 characters"
+  };
+  try {
+    const PerlPass = (await execPromise(`perl -e 'print crypt($ARGV[0], "password")' ${password}`)).stdout;
+    const DateToExpire = `${ExpireDate.getFullYear()}-${(ExpireDate.getMonth() + 1) <= 9 ? "0"+(ExpireDate.getMonth() + 1):(ExpireDate.getMonth() + 1)}-${ExpireDate.getDate() <= 9 ? "0"+ExpireDate.getDate():ExpireDate.getDate()}`;
+    await execFilePromise("useradd", ["-e", DateToExpire, "-M", "-s", "/bin/false", "-p", PerlPass, username]);
+    return {
+      Add: true,
+      Error: null
+    };
+  } catch (err) {
+    const err2 = String(err.stack||err).split("\n");
+    const isExist = /.*user\s+.*\s+already\s+exists/gi.test(err2[1]);
+    return {
+      Add: false,
+      Error: isExist ? "Users Exist" : err2
+    };
+  }
 }

 async function LoadUsers() {
-  const Users = []
-  for (let User of await Moongose.Users.find()) {
-    try {
-      Users.push(await AddtoSystem(User.username, User.ssh.password, new Date(User.expire)));
-    } catch (err) {
-      if (!(/user.*already exists/gi.test(String(err)))) PrintLog(String(err));
-    }
+  for (let User of await OfvpMongo.GetUsers()) {
+    const AddResult = await AddtoSystem(User.username, PasswordEncrypt.DecryptPassword(User.password.iv, User.password.Encrypt), new Date(User.expire));
+    if (!AddResult.Add) Console.err(User.username+":", AddResult.Error);
  }
-  return Users;
 }

 async function RemoveFromSystem(username = "") {
@ -44,27 +85,18 @@ async function RemoveFromSystem(username = "") {
  if (username === "root") throw new Error("You can't delete the root user");
  (await Process.GetProcess()).forEach(Process => {try {if (Process.user === Username) Process.kill_process()} catch (err) {}});
  // Delete
-  child_process.execFileSync("userdel", ["-r", username], {stdio: "pipe"});
+  try {
+    child_process.execFileSync("userdel", ["-r", username], {stdio: "pipe"});
+  } catch (err) {
+    if (/user.*does not exist/gi.test(String(err))) return;
+    throw err;
+  }
  return;
 }

-async function RemoveExpiredUsers() {
-  for (const User of await Moongose.Users.find()) {
-    if ((new Date(User.expire)).getTime() <= (new Date).getTime()) {
-      try {
-        RemoveFromSystem(User.username);
-        PrintLog(`${User.username} has been deleted`);
-      } catch (err) {
-        PrintLog(`Cannot remove ${User.username}`);
-        PrintLog(err);
-      }
-    }
-  }
-}
-
-async function SshLimitConnection() {
+(new CronJob("*/1 * * * *", async function() {
  const CurrentProcess = (await Process.GetProcess()).filter(a => a.command.includes("ssh") && !a.command.includes("defunct"));
-  for (const User of await Moongose.Users.find()) {
+  for (const User of await OfvpMongo.GetUsers()) {
    if (User.ssh.connections !== 0) {
      const SSH_Connections = CurrentProcess.filter(a => a.user === User.username);
      if (User.ssh.connections > SSH_Connections.length) {
@ -74,17 +106,14 @@ async function SshLimitConnection() {
      }
    }
  }
-}
-
-new CronJob("*/1 * * * *", RemoveExpiredUsers);
-new CronJob("*/1 * * * *", SshLimitConnection);
+})).start();

 async function SshMonitor() {
  const CurrentDate = new Date();
  const Current_Process = (await Process.GetProcess()).filter(a => a.command.includes("ssh") && !a.command.includes("defunct"));
  const Connections = {
    BackendDate: CurrentDate.toString(),
-    Users: (await Moongose.Users.find()).map(User => {
+    Users: (await OfvpMongo.GetUsers()).map(User => {
      const SSH_Connections = Current_Process.filter(a => a.user === User.username);
      const Ssh = {
        Username: User.username,
--- a/src/services/v2ray/Service.js
+++ b/src/services/v2ray/Service.js
@ -1,169 +0,0 @@
-const child_process = require("child_process");
-const fs = require("fs");
-const { Users } = require("../../Mongo/Schema");
-
-const BaseConfig = {
-  "log": {
-    "loglevel": "debug",
-  },
-  "inbounds": [
-    {
-      "port": 10086,
-      "protocol": "vmess",
-      "settings": {
-        "clients": [
-          {
-            "id": "e55c8d17-2cf3-b21a-bcf1-eeacb011ed79",
-            "level": 1,
-            "alterId": 233
-          }
-        ]
-      },
-      "streamSettings": {
-        "network": "tcp",
-        "tcpSettings": {
-          "header": {
-            "type": "http",
-            "response": {
-              "version": "1.1",
-              "status": "200",
-              "reason": "OK",
-              "headers": {
-                "Content-encoding": [
-                  "gzip"
-                ],
-                "Content-Type": [
-                  "text/html; charset=utf-8"
-                ],
-                "Cache-Control": [
-                  "no-cache"
-                ],
-                "Vary": [
-                  "Accept-Encoding"
-                ],
-                "X-Frame-Options": [
-                  "deny"
-                ],
-                "X-XSS-Protection": [
-                  "1; mode=block"
-                ],
-                "X-content-type-options": [
-                  "nosniff"
-                ]
-              }
-            }
-          }
-        }
-      },
-      "sniffing": {
-        "enabled": true,
-        "destOverride": [
-          "http",
-          "tls"
-        ]
-      }
-    }
-  ],
-  "outbounds": [
-    {
-      "protocol": "freedom",
-      "settings": {}
-    },
-    {
-      "protocol": "blackhole",
-      "settings": {},
-      "tag": "blocked"
-    },
-    {
-      "protocol": "freedom",
-      "settings": {},
-      "tag": "direct"
-    },
-    {
-      "protocol": "mtproto",
-      "settings": {},
-      "tag": "tg-out"
-    }
-  ],
-  "dns": {
-    "server": [
-      "1.1.1.1",
-      "1.0.0.1",
-      "8.8.8.8",
-      "8.8.4.4",
-      "localhost"
-    ]
-  },
-  "routing": {
-    "domainStrategy": "IPOnDemand",
-    "rules": [
-      {
-        "type": "field",
-        "ip": [
-          "0.0.0.0/8",
-          "10.0.0.0/8",
-          "100.64.0.0/10",
-          "127.0.0.0/8",
-          "169.254.0.0/16",
-          "172.16.0.0/12",
-          "192.0.0.0/24",
-          "192.0.2.0/24",
-          "192.168.0.0/16",
-          "198.18.0.0/15",
-          "198.51.100.0/24",
-          "203.0.113.0/24",
-          "::1/128",
-          "fc00::/7",
-          "fe80::/10"
-        ],
-        "outboundTag": "blocked"
-      },
-      {
-        "type": "field",
-        "inboundTag": ["tg-in"],
-        "outboundTag": "tg-out"
-      }
-    ]
-  },
-  "transport": {
-    "kcpSettings": {
-      "uplinkCapacity": 100,
-      "downlinkCapacity": 100,
-      "congestion": true
-    },
-    "sockopt": {
-      "tcpFastOpen": true
-    }
-  }
-}
-
-async function CreateIdConfig() {
-  const ConfigCopy = BaseConfig;
-  const users = await Users.find({});
-  const userList = users.map(user => {
-    const { id, alterId, level } = user.v2ray;
-    const userConfig = {
-      "id": id,
-      "level": level,
-      "alterId": alterId,
-      "name": user.username
-    };
-    return userConfig;
-  });
-  ConfigCopy.inbounds[0].settings.clients = userList;
-  fs.writeFileSync("/opt/v2ray/config.json", JSON.stringify(ConfigCopy, null, 2));
-  return ConfigCopy;
-}
-
-const v2raybin = "/opt/v2ray/v2ray";
-module.exports = {
-  IsChildProcess: true,
-  AutoRestart: true,
-  maxRestart: 3,
-  name: "v2ray Server",
-  external_restart: () => child_process.execSync("ps aux | grep v2ray | grep -v grep | awk '{print $2}' | xargs kill -9"),
-  start: async () => {
-    await CreateIdConfig();
-    return child_process.execFile(v2raybin, ["-config", "/opt/v2ray/config.json"]);
-  },
-};
--- a/src/services/wireguard/PeerIPs.js
+++ b/src/services/wireguard/PeerIPs.js
@ -1,7 +1,6 @@
 const IpMatching = require("ip-matching");
 const { Netmask } = require("netmask");
-const Moongose = require("../../Mongo/Schema");
-
+const OfvpMongo = require("../../ofvp_mongo");
 const IgnoreIps = [];

 // Thanks to VIJAYABAL DHANAPAL, stackoverflow answer https://stackoverflow.com/a/53760425
@ -49,7 +48,7 @@ function covertIPv6(x = ""){

 async function GetPool() {
  const NetPoolRange = "10.0.0.1-10.0.128.255";
-  const Users = (await Moongose.Users.find()).map(User => User.wireguard.ip);
+  const Users = (await OfvpMongo.UsersSchema.find()).map(User => User.wireguard.ip);
  return IpMatching.getMatch(NetPoolRange).convertToMasks().map((mask) => mask.convertToSubnet().toString()).map((mask) => {
    let Pool = [""];Pool = [];
    (new Netmask(mask)).forEach(ip => Pool.push(ip));
--- a/src/services/wireguard/index.js
+++ b/src/services/wireguard/index.js
@ -3,7 +3,7 @@ const fs = require("fs");
 const path = require("path");
 const WireguardIpManeger = require("./PeerIPs");
 const OfvpNetwork = require("../../ofvp_network");
-const { Users } = require("../../Mongo/Schema");
+const OfvpMongo = require("../../ofvp_mongo");
 const { GetConfig, Config } = require("../../config");
 const qrCode = require("qrcode");
 const js_yaml = require("js-yaml");
@ -40,7 +40,7 @@ async function CreateServerConfig() {
    "",
    "# Server Interface End",
  ];
-  for (let User of await Users.find()) {
+  for (let User of await OfvpMongo.GetUsers()) {
    const { wireguard, username } = User;
    if (wireguard.load) {
      WireConfig.push(
@ -101,7 +101,7 @@ async function CreateConfig() {
 }

 async function CreateClientConfig(User = "", Type = "wireguard", endpoint = "0.0.0.0") {
-  const Client = await Users.findOne({username: User});
+  const Client = await OfvpMongo.findOneUser(User);
  if (!Client) throw new Error("User not found");
  const WireguardServer = GetConfig().Wireguard;
  const ConfigUserInJson = {
				`@ -0,0 +1 @@`
				`@import url("https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css");`