odac 0.9.0 → 1.0.0

package/framework/src/Route.js

@@ -1,455 +0,0 @@
-const fs = require('fs')
-
-const Cron = require('./Route/Cron.js')
-const Internal = require('./Route/Internal.js')
-
-var routes2 = {}
-const mime = {
-  html: 'text/html',
-  css: 'text/css',
-  js: 'text/javascript',
-  json: 'application/json',
-  png: 'image/png',
-  jpg: 'image/jpg',
-  jpeg: 'image/jpeg',
-  svg: 'image/svg+xml',
-  ico: 'image/x-icon',
-  mp3: 'audio/mpeg',
-  mp4: 'video/mp4',
-  webm: 'video/webm',
-  woff: 'font/woff',
-  woff2: 'font/woff2',
-  ttf: 'font/ttf',
-  otf: 'font/otf',
-  eot: 'font/eot',
-  pdf: 'application/pdf',
-  zip: 'application/zip',
-  tar: 'application/x-tar',
-  gz: 'application/gzip',
-  rar: 'application/x-rar-compressed',
-  '7z': 'application/x-7z-compressed',
-  txt: 'text/plain',
-  log: 'text/plain',
-  csv: 'text/csv',
-  xml: 'text/xml',
-  rss: 'application/rss+xml',
-  atom: 'application/atom+xml',
-  yaml: 'application/x-yaml',
-  sh: 'application/x-sh',
-  bat: 'application/x-bat',
-  exe: 'application/x-exe',
-  bin: 'application/x-binary',
-  doc: 'application/msword',
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  xls: 'application/vnd.ms-excel',
-  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  ppt: 'application/vnd.ms-powerpoint',
-  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  avi: 'video/x-msvideo',
-  wmv: 'video/x-ms-wmv',
-  flv: 'video/x-flv',
-  webp: 'image/webp',
-  gif: 'image/gif',
-  bmp: 'image/bmp',
-  tiff: 'image/tiff',
-  tif: 'image/tiff',
-  weba: 'audio/webm',
-  wav: 'audio/wav',
-  ogg: 'audio/ogg',
-  flac: 'audio/flac',
-  aac: 'audio/aac',
-  midi: 'audio/midi'
-}
-
-class Route {
-  loading = false
-  routes = {}
-  auth = {
-    page: (path, authFile, file) => this.authPage(path, authFile, file),
-    post: (path, authFile, file) => this.authPost(path, authFile, file),
-    get: (path, authFile, file) => this.authGet(path, authFile, file)
-  }
-
-  async check(Candy) {
-    let url = Candy.Request.url.split('?')[0]
-    if (url.substr(-1) === '/') url = url.substr(0, url.length - 1)
-
-    if (url.startsWith('/_candy/')) {
-      Candy.Request.route = '_candy_internal'
-    }
-
-    if (['post', 'put', 'patch', 'delete'].includes(Candy.Request.method)) {
-      const formToken = await Candy.request('_candy_form_token')
-      if (formToken) {
-        await Internal.processForm(Candy)
-      }
-    }
-    if (
-      Candy.Request.url === '/' &&
-      Candy.Request.method === 'get' &&
-      Candy.Request.header('X-Candy') === 'token' &&
-      Candy.Request.header('Referer').startsWith((Candy.Request.ssl ? 'https://' : 'http://') + Candy.Request.host + '/') &&
-      Candy.Request.header('X-Candy-Client') === Candy.Request.cookie('candy_client')
-    ) {
-      Candy.Request.header('Access-Control-Allow-Origin', (Candy.Request.ssl ? 'https://' : 'http://') + Candy.Request.host)
-      Candy.Request.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
-      return {
-        token: Candy.token()
-      }
-    }
-
-    // Handle AJAX page load requests
-    if (Candy.Request.method === 'get' && Candy.Request.header('X-Candy') === 'ajaxload') {
-      let loadElements = Candy.Request.header('X-Candy-Load')
-      if (loadElements) {
-        Candy.Request.ajaxLoad = loadElements.split(',')
-      }
-      Candy.Request.isAjaxLoad = true
-      Candy.Request.clientSkeleton = Candy.Request.header('X-Candy-Skeleton')
-    }
-    if (Candy.Config.route && Candy.Config.route[url]) {
-      Candy.Config.route[url] = Candy.Config.route[url].replace('${candy}', `${__dir}/node_modules/candypack`)
-      if (fs.existsSync(Candy.Config.route[url])) {
-        let stat = fs.lstatSync(Candy.Config.route[url])
-        if (stat.isFile()) {
-          let type = 'text/html'
-          if (Candy.Config.route[url].includes('.')) {
-            let arr = Candy.Config.route[url].split('.')
-            type = mime[arr[arr.length - 1]]
-          }
-          Candy.Request.header('Content-Type', type)
-          Candy.Request.header('Cache-Control', 'public, max-age=31536000')
-          Candy.Request.header('Content-Length', stat.size)
-          return fs.readFileSync(Candy.Config.route[url])
-        }
-      }
-    }
-    for (let method of ['#' + Candy.Request.method, Candy.Request.method]) {
-      let controller = this.#controller(Candy.Request.route, method, url)
-      if (controller) {
-        if (!method.startsWith('#') || (await Candy.Auth.check())) {
-          Candy.Request.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
-          if (
-            ['post', 'get'].includes(Candy.Request.method) &&
-            controller.token &&
-            (!(await Candy.request('_token')) || !Candy.token(await Candy.Request.request('_token')))
-          )
-            return Candy.Request.abort(401)
-          if (typeof controller.cache === 'function') {
-            if (controller.params) for (let key in controller.params) Candy.Request.data.url[key] = controller.params[key]
-            return controller.cache(Candy)
-          }
-        }
-      }
-    }
-    let authPageController = this.#controller(Candy.Request.route, '#page', url)
-    if (authPageController && (await Candy.Auth.check())) {
-      if (authPageController.params) for (let key in authPageController.params) Candy.Request.data.url[key] = authPageController.params[key]
-      Candy.Request.page = authPageController.cache?.file || authPageController.file
-      if (typeof authPageController.cache === 'function') {
-        return authPageController.cache(Candy)
-      }
-    }
-    let pageController = this.#controller(Candy.Request.route, 'page', url)
-    if (pageController) {
-      if (pageController.params) for (let key in pageController.params) Candy.Request.data.url[key] = pageController.params[key]
-      Candy.Request.page = pageController.cache?.file || pageController.file
-      if (typeof pageController.cache === 'function') {
-        return pageController.cache(Candy)
-      }
-    }
-    if (url && !url.includes('/../') && fs.existsSync(`${__dir}/public${url}`)) {
-      let stat = fs.lstatSync(`${__dir}/public${url}`)
-      if (stat.isFile()) {
-        let type = 'text/html'
-        if (url.includes('.')) {
-          let arr = url.split('.')
-          type = mime[arr[arr.length - 1]]
-        }
-        Candy.Request.header('Content-Type', type)
-        Candy.Request.header('Cache-Control', 'public, max-age=31536000')
-        Candy.Request.header('Content-Length', stat.size)
-        return fs.readFileSync(`${__dir}/public${url}`)
-      }
-    }
-    return Candy.Request.abort(404)
-  }
-
-  #controller(route, method, url) {
-    if (!this.routes[route] || !this.routes[route][method]) return false
-    if (this.routes[route][method][url]) return this.routes[route][method][url]
-    let arr = url.split('/')
-    for (let key in this.routes[route][method]) {
-      if (!key.includes('{') || !key.includes('}')) continue
-      let route_arr = key.split('/')
-      if (route_arr.length !== arr.length) continue
-      let params = {}
-      let next = false
-      for (let i = 0; i < route_arr.length; i++) {
-        if (route_arr[i].includes('{') && route_arr[i].includes('}')) {
-          params[route_arr[i].replace('{', '').replace('}', '')] = arr[i]
-          arr[i] = route_arr[i]
-        } else if (route_arr[i] !== arr[i]) {
-          next = true
-          break
-        }
-      }
-      if (next) continue
-      if (arr.join('/') === key)
-        return {
-          params: params,
-          cache: this.routes[route][method][key].cache,
-          token: this.routes[route][method][key].token
-        }
-    }
-    return false
-  }
-
-  #init() {
-    if (this.loading) return
-    this.loading = true
-    for (const file of fs.readdirSync(`${__dir}/controller/`)) {
-      if (file.substr(-3) !== '.js') continue
-      let name = file.replace('.js', '')
-      if (!Candy.Route.class) Candy.Route.class = {}
-      if (Candy.Route.class[name]) {
-        if (Candy.Route.class[name].mtime >= fs.statSync(Candy.Route.class[name].path).mtimeMs + 1000) continue
-        delete require.cache[require.resolve(Candy.Route.class[name].path)]
-      }
-      Candy.Route.class[name] = {
-        path: `${__dir}/controller/${file}`,
-        mtime: fs.statSync(`${__dir}/controller/${file}`).mtimeMs,
-        module: require(`${__dir}/controller/${file}`)
-      }
-    }
-    let dir = fs.readdirSync(`${__dir}/route/`)
-    for (const file of dir) {
-      if (file.substr(-3) !== '.js') continue
-      let mtime = fs.statSync(`${__dir}/route/${file}`).mtimeMs
-      Candy.Route.buff = file.replace('.js', '')
-      if (!routes2[Candy.Route.buff] || routes2[Candy.Route.buff] < mtime - 1000) {
-        delete require.cache[require.resolve(`${__dir}/route/${file}`)]
-        routes2[Candy.Route.buff] = mtime
-        require(`${__dir}/route/${file}`)
-      }
-      for (const type of ['page', '#page', 'post', '#post', 'get', '#get', 'error']) {
-        if (!this.routes[Candy.Route.buff]) continue
-        if (!this.routes[Candy.Route.buff][type]) continue
-        for (const route in this.routes[Candy.Route.buff][type]) {
-          if (routes2[Candy.Route.buff] > this.routes[Candy.Route.buff][type][route].loaded) {
-            delete require.cache[require.resolve(this.routes[Candy.Route.buff][type][route].path)]
-            delete this.routes[Candy.Route.buff][type][route]
-          } else if (this.routes[Candy.Route.buff][type][route]) {
-            if (typeof this.routes[Candy.Route.buff][type][route].type === 'function') continue
-            if (this.routes[Candy.Route.buff][type][route].mtime < fs.statSync(this.routes[Candy.Route.buff][type][route].path).mtimeMs) {
-              delete require.cache[require.resolve(this.routes[Candy.Route.buff][type][route].path)]
-              this.routes[Candy.Route.buff][type][route].cache = require(this.routes[Candy.Route.buff][type][route].path)
-              this.routes[Candy.Route.buff][type][route].mtime = fs.statSync(this.routes[Candy.Route.buff][type][route].path).mtimeMs
-            }
-          }
-        }
-      }
-      delete Candy.Route.buff
-    }
-    Cron.init()
-    this.loading = false
-  }
-
-  init() {
-    this.#init()
-    this.#registerInternalRoutes()
-    setInterval(() => {
-      this.#init()
-    }, 5000)
-  }
-
-  #registerInternalRoutes() {
-    if (!Candy.Route) Candy.Route = {}
-    Candy.Route.buff = '_candy_internal'
-
-    this.set(
-      'POST',
-      '/_candy/register',
-      async Candy => {
-        const csrfToken = await Candy.request('_token')
-        if (!csrfToken || !Candy.token(csrfToken)) {
-          return Candy.Request.abort(401)
-        }
-        return await Internal.register(Candy)
-      },
-      {token: true}
-    )
-
-    this.set(
-      'POST',
-      '/_candy/login',
-      async Candy => {
-        const csrfToken = await Candy.request('_token')
-        if (!csrfToken || !Candy.token(csrfToken)) {
-          return Candy.Request.abort(401)
-        }
-        return await Internal.login(Candy)
-      },
-      {token: true}
-    )
-
-    this.set(
-      ['POST', 'GET', 'PUT', 'PATCH', 'DELETE'],
-      '/_candy/form',
-      async Candy => {
-        const csrfToken = await Candy.request('_token')
-        if (!csrfToken || !Candy.token(csrfToken)) {
-          return Candy.Request.abort(401)
-        }
-        const result = await Internal.customForm(Candy)
-        if (result !== null) return result
-
-        return Candy.return({
-          result: {
-            success: false,
-            message: 'No handler defined for this form'
-          },
-          errors: {_candy_form: 'Form action not configured'}
-        })
-      },
-      {token: true}
-    )
-
-    delete Candy.Route.buff
-  }
-
-  async request(req, res) {
-    let id = `${Date.now()}${Math.random().toString(36).substr(2, 9)}`
-    let param = Candy.instance(id, req, res)
-    if (!this.routes[param.Request.route]) return param.Request.end()
-    try {
-      let result = this.check(param)
-      if (result instanceof Promise) result = await result
-      const Stream = require('./Stream.js')
-      if (result instanceof Stream) return
-      if (param.Request.res.finished || param.Request.res.writableEnded) return
-      if (result) param.Request.end(result)
-      await param.View.print(param)
-      param.Request.print(param)
-    } catch (e) {
-      console.error(e)
-      param.Request.abort(500)
-      return param.Request.end()
-    }
-  }
-
-  set(type, url, file, options = {}) {
-    if (Array.isArray(type)) {
-      type = type.map(t => t.toLowerCase())
-      for (const t of type) {
-        this.set(t, url, file, options)
-      }
-      return
-    }
-
-    if (!options) options = {}
-    if (typeof url !== 'string') url = String(url)
-    if (url.length && url.substr(-1) === '/') url = url.substr(0, url.length - 1)
-
-    type = type.toLowerCase()
-
-    const isFunction = typeof file === 'function'
-    let path = `${__dir}/route/${Candy.Route.buff}.js`
-
-    if (!isFunction && file) {
-      path = `${__dir}/controller/${type.replace('#', '')}/${file}.js`
-      if (typeof file === 'string' && file.includes('.')) {
-        let arr = file.split('.')
-        path = `${__dir}/controller/${arr[0]}/${type.replace('#', '')}/${arr.slice(1).join('.')}.js`
-      }
-    }
-
-    if (!this.routes[Candy.Route.buff]) this.routes[Candy.Route.buff] = {}
-    if (!this.routes[Candy.Route.buff][type]) this.routes[Candy.Route.buff][type] = {}
-
-    if (this.routes[Candy.Route.buff][type][url]) {
-      this.routes[Candy.Route.buff][type][url].loaded = routes2[Candy.Route.buff]
-      if (!isFunction && this.routes[Candy.Route.buff][type][url].mtime < fs.statSync(path).mtimeMs) {
-        delete this.routes[Candy.Route.buff][type][url]
-        delete require.cache[require.resolve(path)]
-      } else return
-    }
-
-    if (isFunction || fs.existsSync(path)) {
-      if (!this.routes[Candy.Route.buff][type][url]) this.routes[Candy.Route.buff][type][url] = {}
-      this.routes[Candy.Route.buff][type][url].cache = isFunction ? file : require(path)
-      this.routes[Candy.Route.buff][type][url].type = isFunction ? 'function' : 'controller'
-      this.routes[Candy.Route.buff][type][url].file = file
-      this.routes[Candy.Route.buff][type][url].mtime = isFunction ? Date.now() : fs.statSync(path).mtimeMs
-      this.routes[Candy.Route.buff][type][url].path = path
-      this.routes[Candy.Route.buff][type][url].loaded = routes2[Candy.Route.buff]
-      this.routes[Candy.Route.buff][type][url].token = options.token ?? true
-    }
-  }
-
-  page(path, file) {
-    if (typeof file === 'object' && !Array.isArray(file)) {
-      this.set('page', path, _candy => {
-        _candy.View.set(file)
-        return
-      })
-      return
-    }
-    if (file) this.set('page', path, file)
-  }
-
-  post(path, file, options) {
-    this.set('post', path, file, options)
-  }
-
-  get(path, file, options) {
-    this.set('get', path, file, options)
-  }
-
-  authPage(path, authFile, file) {
-    if (typeof authFile === 'object' && !Array.isArray(authFile)) {
-      this.set('#page', path, _candy => {
-        _candy.View.set(authFile)
-        return
-      })
-      if (typeof file === 'object' && !Array.isArray(file)) {
-        this.set('page', path, _candy => {
-          _candy.View.set(file)
-          return
-        })
-      }
-      return
-    }
-    if (authFile) this.set('#page', path, authFile)
-    if (file) {
-      if (typeof file === 'object' && !Array.isArray(file)) {
-        this.set('page', path, _candy => {
-          _candy.View.set(file)
-          return
-        })
-      } else {
-        this.set('page', path, file)
-      }
-    }
-  }
-
-  authPost(path, authFile, file) {
-    if (authFile) this.set('#post', path, authFile)
-    if (file) this.post(path, file)
-  }
-
-  authGet(path, authFile, file) {
-    if (authFile) this.set('#get', path, authFile)
-    if (file) this.get(path, file)
-  }
-
-  error(code, file) {
-    this.set('error', code, file)
-  }
-
-  cron(controller) {
-    return Cron.job(controller)
-  }
-}
-
-module.exports = Route

package/framework/src/Server.js

@@ -1,15 +0,0 @@
-const http = require(`http`)
-
-module.exports = {
-  init: function () {
-    let args = process.argv.slice(2)
-    if (args[0] == 'framework' && args[1] == 'run') args = args.slice(2)
-    let port = parseInt(args[0] ?? '1071')
-    console.log(`CandyPack Server running on \x1b]8;;http://127.0.0.1:${port}\x1b\\\x1b[4mhttp://127.0.0.1:${port}\x1b[0m\x1b]8;;\x1b\\.`)
-    http
-      .createServer((req, res) => {
-        return Candy.Route.request(req, res)
-      })
-      .listen(port)
-  }
-}

package/locale/de-DE.json

@@ -1,80 +0,0 @@
-{
-  "Restart CandyPack Server": "CandyPack-Server neu starten",
-  "Login to CandyPack Server": "Beim CandyPack-Server anmelden",
-  "Status": "Status",
-  "Starting CandyPack Server...": "CandyPack-Server wird gestartet...",
-  "Uptime": "Betriebszeit",
-  "Running": "Läuft",
-  "Auth": "Authentifizierung",
-  "Online": "Online",
-  "%s Services": "%s Dienste",
-  "Not logged in": "Nicht angemeldet",
-  "Login on %s to manage all your server operations.": "Melden Sie sich bei %s an, um alle Ihre Server-Operationen zu verwalten.",
-  "Start a CandyPack Service": "Einen CandyPack-Dienst starten",
-  "Create a new Website": "Eine neue Website erstellen",
-  "Delete a website": "Eine Website löschen",
-  "List all CandyPack Services": "Alle CandyPack-Dienste auflisten",
-  "List all CandyPack Websites": "Alle CandyPack-Websites auflisten",
-  "Websites": "Websites",
-  "Services": "Dienste",
-  "Website %s doesn't have index.js file.": "Website %s hat keine index.js-Datei.",
-  "Monitor Website or Service": "Website oder Dienst überwachen",
-  "Offline": "Offline",
-  "Restarting CandyPack Server...": "CandyPack-Server wird neu gestartet...",
-  "Define your server to your CandyPack account": "Definieren Sie Ihren Server für Ihr CandyPack-Konto",
-  "Insert Domain (example.com): ": "Domain eingeben (beispiel.com): ",
-  "Commands:": "Befehle:",
-  "Create a new Subdomain": "Eine neue Subdomain erstellen",
-  "List all available commands": "Alle verfügbaren Befehle auflisten",
-  "Website Management": "Website-Verwaltung",
-  "Help": "Hilfe",
-  "Add a new subdomain": "Eine neue Subdomain hinzufügen",
-  "WEBSITE MANAGEMENT": "WEBSITE-VERWALTUNG",
-  "HELP": "HILFE",
-  "Debug CandyPack Server": "CandyPack-Server debuggen",
-  "Add a new Service": "Einen neuen Dienst hinzufügen",
-  "Domains": "Domänen",
-  "Service %s added.": "Dienst %s hinzugefügt.",
-  "Name": "Name",
-  "Active": "Aktiv",
-  "Errored": "Fehlerhaft",
-  "Create a new mail account": "Ein neues E-Mail-Konto erstellen",
-  "Delete a mail account": "Ein E-Mail-Konto löschen",
-  "List all domain mail accounts": "Alle E-Mail-Konten einer Domain auflisten",
-  "Change mail account password": "Passwort des E-Mail-Kontos ändern",
-  "Renew SSL certificate for a domain": "SSL-Zertifikat für eine Domain erneuern",
-  "List all domain subdomains": "Alle Subdomains einer Domain auflisten",
-  "'%s' is not a valid command.": "'%s' ist kein gültiger Befehl.",
-  "List all websites": "Alle Websites auflisten",
-  "No websites found.": "Keine Websites gefunden.",
-  "Service %s is not running.": "Dienst %s läuft nicht.",
-  "Service %s not found.": "Dienst %s nicht gefunden.",
-  "Enter the path to the website (%s): ": "Geben Sie den Pfad zur Website (%s) ein: ",
-  "Website %s created.": "Website %s wurde erstellt.",
-  "Websites:": "Websites:",
-  "Website %s deleted.": "Website %s wurde gelöscht.",
-  "Invalid domain.": "Ungültige Domain.",
-  "Website %s1 created at %s2.": "Website %s1 wurde an %s2 erstellt.",
-  "Enter the domain name: ": "Geben Sie den Domainnamen ein: ",
-  "Modules": "Module",
-  "Logs": "Protokolle",
-  "Navigate": "Navigieren",
-  "Select": "Auswählen",
-  "Exit": "Beenden",
-  "Website %s already exists.": "Website %s existiert bereits.",
-  "Website %s not found.": "Website %s nicht gefunden.",
-  "Create a new website": "Eine neue Website erstellen",
-  "Setting up domain %s...": "Domain %s wird eingerichtet...",
-  "Domain %s set.": "Domain %s wurde festgelegt.",
-  "Setting up website files for %s...": "Website-Dateien für %s werden eingerichtet...",
-  "Website files for %s set.": "Website-Dateien für %s wurden festgelegt.",
-  "Setting up DNS records for %s...": "DNS-Einträge für %s werden eingerichtet...",
-  "DNS records for %s set.": "DNS-Einträge für %s wurden festgelegt.",
-  "Setting up SSL certificate for %s...": "SSL-Zertifikat für %s wird eingerichtet...",
-  "SSL certificate for domain %s renewed successfully.": "SSL-Zertifikat für Domain %s wurde erfolgreich erneuert.",
-  "Subdomain %s1 created successfully for domain %s2.": "Subdomain %s1 wurde erfolgreich für Domain %s2 erstellt.",
-  "Invalid subdomain name.": "Ungültiger Subdomain-Name.",
-  "Subdomain %s1 deleted successfully from domain %s2.": "Subdomain %s1 wurde erfolgreich von Domain %s2 gelöscht.",
-  "%s is a domain.": "%s ist eine Domain.",
-  "Enter the subdomain name (subdomain.example.com): ": "Geben Sie den Subdomain-Namen ein (subdomain.example.com): "
-}

package/locale/en-US.json

@@ -1,79 +0,0 @@
-{
-  "Restart CandyPack Server": "Restart CandyPack Server",
-  "Login to CandyPack Server": "Login to CandyPack Server",
-  "Status": "Status",
-  "Starting CandyPack Server...": "Starting CandyPack Server...",
-  "Uptime": "Uptime",
-  "Running": "Running",
-  "Auth": "Auth",
-  "Online": "Online",
-  "%s Services": "%s Services",
-  "Not logged in": "Not logged in",
-  "Login on %s to manage all your server operations.": "Login on %s to manage all your server operations.",
-  "Start a CandyPack Service": "Start a CandyPack Service",
-  "Create a new Website": "Create a new Website",
-  "Delete a website": "Delete a website",
-  "List all CandyPack Services": "List all CandyPack Services",
-  "List all CandyPack Websites": "List all CandyPack Websites",
-  "Websites": "Websites",
-  "Services": "Services",
-  "Website %s doesn't have index.js file.": "Website %s doesn't have index.js file.",
-  "Monitor Website or Service": "Monitor Website or Service",
-  "Offline": "Offline",
-  "Restarting CandyPack Server...": "Restarting CandyPack Server...",
-  "Define your server to your CandyPack account": "Define your server to your CandyPack account",
-  "Insert Domain (example.com): ": "Insert Domain (example.com): ",
-  "Commands:": "Commands:",
-  "Create a new Subdomain": "Create a new Subdomain",
-  "List all available commands": "List all available commands",
-  "Website Management": "Website Management",
-  "Help": "Help",
-  "Add a new subdomain": "Add a new subdomain",
-  "WEBSITE MANAGEMENT": "WEBSITE MANAGEMENT",
-  "HELP": "HELP",
-  "Debug CandyPack Server": "Debug CandyPack Server",
-  "Add a new Service": "Add a new Service",
-  "Domains": "Domains",
-  "Service %s added.": "Service %s added.",
-  "Name": "Name",
-  "Active": "Active",
-  "Errored": "Errored",
-  "Create a new mail account": "Create a new mail account",
-  "Delete a mail account": "Delete a mail account",
-  "List all domain mail accounts": "List all domain mail accounts",
-  "Change mail account password": "Change mail account password",
-  "Renew SSL certificate for a domain": "Renew SSL certificate for a domain",
-  "List all domain subdomains": "List all domain subdomains",
-  "'%s' is not a valid command.": "'%s' is not a valid command.",
-  "List all websites": "List all websites",
-  "No websites found.": "No websites found.",
-  "Service %s is not running.": "Service %s is not running.",
-  "Service %s not found.": "Service %s not found.",
-  "Website %s created.": "Website %s created.",
-  "Websites:": "Websites:",
-  "Website %s deleted.": "Website %s deleted.",
-  "Invalid domain.": "Invalid domain.",
-  "Website %s1 created at %s2.": "Website %s1 created at %s2.",
-  "Enter the domain name: ": "Enter the domain name: ",
-  "Modules": "Modules",
-  "Logs": "Logs",
-  "Navigate": "Navigate",
-  "Select": "Select",
-  "Exit": "Exit",
-  "Website %s already exists.": "Website %s already exists.",
-  "Website %s not found.": "Website %s not found.",
-  "Create a new website": "Create a new website",
-  "Setting up domain %s...": "Setting up domain %s...",
-  "Domain %s set.": "Domain %s set.",
-  "Setting up website files for %s...": "Setting up website files for %s...",
-  "Website files for %s set.": "Website files for %s set.",
-  "Setting up DNS records for %s...": "Setting up DNS records for %s...",
-  "DNS records for %s set.": "DNS records for %s set.",
-  "Setting up SSL certificate for %s...": "Setting up SSL certificate for %s...",
-  "SSL certificate for domain %s renewed successfully.": "SSL certificate for domain %s renewed successfully.",
-  "Subdomain %s1 created successfully for domain %s2.": "Subdomain %s1 created successfully for domain %s2.",
-  "Invalid subdomain name.": "Invalid subdomain name.",
-  "Subdomain %s1 deleted successfully from domain %s2.": "Subdomain %s1 deleted successfully from domain %s2.",
-  "%s is a domain.": "%s is a domain.",
-  "Enter the subdomain name (subdomain.example.com): ": "Enter the subdomain name (subdomain.example.com): "
-}