mirror of
https://github.com/Troplo/Colubrina.git
synced 2024-11-22 19:27:55 +11:00
350 lines
10 KiB
JavaScript
350 lines
10 KiB
JavaScript
const input = require("input")
|
|
const fs = require("fs")
|
|
const path = require("path")
|
|
const { Umzug, SequelizeStorage } = require("umzug")
|
|
const { Sequelize } = require("sequelize")
|
|
const argon2 = require("argon2")
|
|
const axios = require("axios")
|
|
const os = require("os")
|
|
const { execSync } = require("child_process")
|
|
|
|
console.log("Troplo/Colubrina CLI")
|
|
if (fs.existsSync("../backend/config/config.json")) {
|
|
console.log(
|
|
"Want to modify either the Colubrina, or database config? Check out the config files in backend/config."
|
|
)
|
|
}
|
|
console.log("Colubrina version", require("../frontend/package.json").version)
|
|
async function checkForUpdates() {
|
|
if (!process.argv.includes("--skip-update")) {
|
|
await axios
|
|
.get("https://services.troplo.com/api/v1/state", {
|
|
headers: {
|
|
"X-Troplo-Project": "colubrina",
|
|
"X-Troplo-Project-Version": require("../frontend/package.json")
|
|
.version
|
|
},
|
|
timeout: 1000
|
|
})
|
|
.then((res) => {
|
|
if (res.data.warning) {
|
|
console.log(res.data.warning)
|
|
}
|
|
if (
|
|
require("../frontend/package.json").version !== res.data.latestVersion
|
|
) {
|
|
console.log("A new version of Colubrina is available!")
|
|
console.log("Latest version:", res.data.latestVersion)
|
|
} else {
|
|
console.log("Colubrina is up to date.")
|
|
}
|
|
})
|
|
.catch((e) => {
|
|
console.log(e)
|
|
console.log(
|
|
"Failed to check for updates, ensure you are connected to the internet, and services.troplo.com is whitelisted behind any potential firewalls."
|
|
)
|
|
})
|
|
} else {
|
|
console.log("Skipping update check")
|
|
}
|
|
}
|
|
let state = {
|
|
db: {
|
|
host: "localhost",
|
|
port: 3306,
|
|
username: "colubrina",
|
|
password: null,
|
|
database: "colubrina",
|
|
storage: "../backend/storage.db",
|
|
dialect: "mariadb"
|
|
},
|
|
dbConfig: {}
|
|
}
|
|
async function doSetupDB() {
|
|
const dialect = await input.select(
|
|
"What database dialect do you want to use? (MariaDB tested, recommended)",
|
|
["mariadb", "postgres", "sqlite"]
|
|
)
|
|
const host = await input.text("What is the host?", {
|
|
default: state.db.host || "localhost"
|
|
})
|
|
const port = await input.text("What is the port?", {
|
|
default: state.db.port || 3306
|
|
})
|
|
const username = await input.text("What is the username?", {
|
|
default: state.db.username || "colubrina"
|
|
})
|
|
const password = await input.text("What is the password?", {
|
|
default: state.db.password ? "Enter for cached password" : "Please specify"
|
|
})
|
|
const database = await input.text("What is the database name?", {
|
|
default: state.db.database || "colubrina"
|
|
})
|
|
let storage
|
|
if (dialect === "sqlite") {
|
|
storage = await input.text(
|
|
"What is the path to the storage file (SQLite only)?",
|
|
{
|
|
default: state.db.storage || "./storage.db"
|
|
}
|
|
)
|
|
}
|
|
state.db = {
|
|
username: username,
|
|
password: password,
|
|
database: database,
|
|
host: host,
|
|
dialect: dialect,
|
|
port: port,
|
|
logging: false
|
|
}
|
|
state.dbConfig = {
|
|
development: {
|
|
username: username,
|
|
password: password,
|
|
database: database,
|
|
host: host,
|
|
dialect: dialect,
|
|
port: port,
|
|
storage: dialect === "sqlite" ? storage : null,
|
|
logging: false
|
|
},
|
|
test: {
|
|
username: username,
|
|
password: password,
|
|
database: database,
|
|
host: host,
|
|
dialect: dialect,
|
|
port: port,
|
|
logging: false
|
|
},
|
|
production: {
|
|
username: username,
|
|
password: password,
|
|
database: database,
|
|
host: host,
|
|
dialect: dialect,
|
|
port: port,
|
|
logging: false
|
|
}
|
|
}
|
|
await testDB()
|
|
}
|
|
async function testDB() {
|
|
try {
|
|
const sequelize = new Sequelize(state.db)
|
|
await sequelize.authenticate()
|
|
console.log("Connection to database has been established successfully.")
|
|
} catch (error) {
|
|
console.error("Unable to connect to the database:", error)
|
|
await doSetupDB()
|
|
}
|
|
}
|
|
async function dbSetup() {
|
|
await doSetupDB()
|
|
fs.writeFileSync(
|
|
path.join(__dirname, "../backend/config/database.json"),
|
|
JSON.stringify(state.dbConfig, null, 2)
|
|
)
|
|
console.log("config/database.json overwritten")
|
|
}
|
|
async function runMigrations() {
|
|
console.log("Running migrations")
|
|
execSync("cd ../backend && sequelize db:migrate", () => {
|
|
console.log("Migrations applied")
|
|
})
|
|
}
|
|
async function createUser() {
|
|
const user = {
|
|
username: await input.text("Username", {
|
|
default: "admin"
|
|
}),
|
|
password: await argon2.hash(await input.text("Password", {})),
|
|
email: await input.text("Email", {
|
|
default: "troplo@troplo.com"
|
|
}),
|
|
admin: await input.confirm("Admin (true/false)", {
|
|
default: false
|
|
}),
|
|
emailVerified: await input.confirm("Email verified (true/false)", {
|
|
default: true
|
|
})
|
|
}
|
|
const { User } = require("../backend/models")
|
|
await User.create(user)
|
|
console.log("User created")
|
|
}
|
|
async function configureDotEnv() {
|
|
if (!fs.existsSync("../backend/config/config.json")) {
|
|
fs.writeFileSync("../backend/config/config.json", "{}")
|
|
}
|
|
let config = require("../backend/config/config.json")
|
|
config.hostname = await input.text("Public Domain", {
|
|
default: "localhost"
|
|
})
|
|
config.corsHostname = await input.text("CORS Hostname", {
|
|
default: "http://localhost"
|
|
})
|
|
config.siteName = await input.text("Site Name", {
|
|
default: "Colubrina"
|
|
})
|
|
config.allowRegistrations = await input.text("Allow Registrations", {
|
|
default: true
|
|
})
|
|
config.publicUsers = await input.text("Show instance users publicly?", {
|
|
default: true
|
|
})
|
|
config.emailVerify = await input.text("Enforce email verification?", {
|
|
default: false
|
|
})
|
|
if (config.emailVerify) {
|
|
config.emailSMTPHost = await input.text("SMTP Host", {
|
|
default: "mail.example.com"
|
|
})
|
|
config.emailSMTPPort = await input.text("SMTP Port", {
|
|
default: 587
|
|
})
|
|
config.emailSMTPUsername = await input.text("SMTP Username", {
|
|
default: "colubrina@example.com"
|
|
})
|
|
config.emailSMTPPassword = await input.text("SMTP Password", {})
|
|
config.emailSMTPFrom = await input.text("SMTP From Address", {
|
|
default: "colubrina@example.com"
|
|
})
|
|
config.emailSMTPSecure = await input.text("SMTP Secure", {
|
|
default: true
|
|
})
|
|
} else {
|
|
config.emailSMTPHost = "smtp.myhost.com"
|
|
config.emailSMTPPort = 587
|
|
config.emailSMTPUsername = "colubrina@example.com"
|
|
config.emailSMTPFrom = "colubrina@example.com"
|
|
config.emailSMTPPassword = ""
|
|
config.emailSMTPSecure = true
|
|
}
|
|
config.notification = ""
|
|
config.notificationType = "info"
|
|
config.release = "stable"
|
|
config.rules = "Write your instance rules here."
|
|
fs.writeFileSync(
|
|
"../backend/config/config.json",
|
|
JSON.stringify(config, null, 2)
|
|
)
|
|
}
|
|
async function init() {
|
|
while (true) {
|
|
const option = await input.select(`Please select an option`, [
|
|
"First-time setup",
|
|
"Create user",
|
|
"Run migrations",
|
|
"Update/create database config file",
|
|
"Check for updates",
|
|
"Build frontend for production",
|
|
"Exit"
|
|
])
|
|
|
|
if (option === "First-time setup") {
|
|
// run yarn install in ../backend
|
|
console.log("Running yarn install")
|
|
execSync("cd ../backend && yarn install --frozen-lockfile", () => {
|
|
console.log("yarn install complete (backend)")
|
|
})
|
|
execSync("cd ../frontend && yarn install --frozen-lockfile", () => {
|
|
console.log("yarn install complete (frontend)")
|
|
})
|
|
if (
|
|
fs.existsSync(path.join(__dirname, "../backend/config/config.json"))
|
|
) {
|
|
const option = await input.confirm(
|
|
"Colubrina config already exists, overwrite?",
|
|
{
|
|
default: false
|
|
}
|
|
)
|
|
if (option) {
|
|
await configureDotEnv()
|
|
}
|
|
} else {
|
|
await configureDotEnv()
|
|
}
|
|
if (
|
|
fs.existsSync(path.join(__dirname, "../backend/config/database.json"))
|
|
) {
|
|
const option = await input.select(
|
|
`config/database.json already exists. Do you want to overwrite it?`,
|
|
["Yes", "No"]
|
|
)
|
|
if (option === "Yes") {
|
|
await dbSetup()
|
|
}
|
|
} else {
|
|
await dbSetup()
|
|
}
|
|
await runMigrations()
|
|
const { User, Theme } = require("../backend/models")
|
|
try {
|
|
await Theme.bulkCreate(
|
|
JSON.parse(
|
|
fs.readFileSync(path.join(__dirname, "./templates/themes.json"))
|
|
)
|
|
)
|
|
} catch {
|
|
console.log("Themes already exist.")
|
|
}
|
|
try {
|
|
await User.create({
|
|
username: "Colubrina",
|
|
id: 0,
|
|
bot: true,
|
|
email: "colubrina@troplo.com",
|
|
banned: true
|
|
})
|
|
await User.update(
|
|
{
|
|
id: 0
|
|
},
|
|
{
|
|
where: {
|
|
username: "Colubrina"
|
|
}
|
|
}
|
|
)
|
|
} catch {
|
|
console.log("System user already exists.")
|
|
}
|
|
console.log("DB templates applied")
|
|
console.log("Admin user creation")
|
|
await createUser()
|
|
console.log("Colubrina has been setup.")
|
|
console.log(
|
|
"Colubrina can be started with `yarn serve` or `node .` in the backend directory."
|
|
)
|
|
console.log(
|
|
"The Colubrina frontend can be built with `yarn build` in the root project directory, and is recommended to be served via NGINX, with a proxy_pass to the backend on /api and /socket.io."
|
|
)
|
|
} else if (option === "Update/create database config file") {
|
|
await dbSetup()
|
|
console.log("config/database.json overwritten or created")
|
|
} else if (option === "Create user") {
|
|
await createUser()
|
|
} else if (option === "Run migrations") {
|
|
await runMigrations()
|
|
} else if (option === "Check for updates") {
|
|
await checkForUpdates()
|
|
} else if (option === "Build frontend for production") {
|
|
console.log("Building...")
|
|
execSync(
|
|
"cd ../frontend && yarn install --frozen-lockfile && yarn build",
|
|
() => {
|
|
console.log("yarn build complete")
|
|
}
|
|
)
|
|
} else if (option === "Exit") {
|
|
process.exit(0)
|
|
}
|
|
}
|
|
}
|
|
checkForUpdates().finally(() => {
|
|
init()
|
|
})
|