branches/4.x/setup.js

#!/bin/node

/**
* setup.js -- the installer script
* 
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by 
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License 
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

const path = require('path');
const fs = require('fs/promises');
const readline = require('readline');
const bcrypt = require('bcrypt');

const CONFIG_DIR = path.resolve(__dirname, 'config');
const { version } = require('./package.json');
const { existsSync } = require('fs');
const SAMPLE_CONFIG_PATH = path.resolve(CONFIG_DIR, 'sample-config.json');
const CONFIG_PATH = path.resolve(CONFIG_DIR, 'config.json');

const isSnowflake = text => /^\d+$/.test(text);

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

const prompt = text => new Promise(resolve => {
    rl.question(text, resolve);
});

const promptDefault = async (text, defaultValue) => {
    const input = await prompt(text);

    if (input.toString().trim() === '') {
        return defaultValue;
    }

    return input;
};

const promptLoop = async (text, validator, defaultValue) => {
    let fn = promptDefault;

    if (defaultValue === undefined) {
        fn = prompt;
    }

    const input = await fn(text, defaultValue);

    if (!(await validator(input ?? ''))) {
        return promptLoop(text, validator, defaultValue);
    }

    return input ?? '';
};

const snowflakeValidator = input => {
    if (!isSnowflake(input)) {
        console.log(`That's not a valid snowflake! Please enter a valid ID.`);
        return false;
    }

    return true;
};

(async () => {
    console.log(`SudoBot version ${version}`);
    console.log(`Copyright (C) OSN Inc 2022`);
    console.log(`Thanks for using SudoBot! We'll much appreciate if you star the repository on GitHub.\n`);

    let prefix = '-', homeGuild = '', owners = [];
    let config = Object.entries(JSON.parse((await fs.readFile(SAMPLE_CONFIG_PATH)).toString()));
    
    config[1][1].prefix = (await promptLoop(`What will be the bot prefix? [${prefix}]: `, input => {
        if (input.trim().includes(' ')) {
            console.log(`Prefixes must not contain spaces!`);
            return false;
        }

        return true;
    }, "-")).trim();

    homeGuild = await promptLoop(`What will be the Home/Support Guild ID?: `, snowflakeValidator);
    config[1][0] = homeGuild;

    config = Object.fromEntries(config);

    config.global.id = homeGuild;
    config.global.owners = (await promptLoop(`Who will be the owner? Specify the owner user IDs separated with comma (,): `, input => {
        const splitted = input.split(',');

        for (const snowflake of splitted) {
            if (!snowflakeValidator(snowflake)) {
                console.log(`Invalid snowflake given! Make sure that the IDs are correctly given!`);
                return false;
            }
        }

        return true;
    })).split(',').map(s => s.trim());

    // config[1][0] = homeGuild;
    // config[1][1].prefix = prefix;

    // config.global.owners = owners;

    const guildConfig = {...config[homeGuild]};

    guildConfig.mod_role = await promptLoop(`What will be the moderator role ID?: `, snowflakeValidator);
    guildConfig.admin = await promptLoop(`What will be the safe role ID?: `, snowflakeValidator);
    guildConfig.mute_role = await promptLoop(`What will be the muted role ID?: `, snowflakeValidator);
    guildConfig.gen_role = await promptLoop(`What will be the general role ID? [${homeGuild}]: `, snowflakeValidator, homeGuild);
    guildConfig.logging_channel = await promptLoop(`What will be the main logging channel ID?: `, snowflakeValidator);
    guildConfig.logging_channel_join_leave = await promptLoop(`What will be the join/leave logging channel ID?: `, snowflakeValidator);

    config[homeGuild] = guildConfig;

    console.log(config);

    if (existsSync(CONFIG_PATH)) {
        const input = await promptDefault("The config file (config/config.json) already exists. Do you want to overwrite the file? [y/N]: ", "n");

        if (input.trim().toLowerCase() !== "y" && input.trim().toLowerCase() !== "yes") {
            console.log("Aborting setup.");
            rl.close();
            process.exit(1);
        }
    }

    if (existsSync(CONFIG_PATH))
        await fs.rename(CONFIG_PATH, path.join(CONFIG_DIR, 'config-old-' + Math.round(Math.random() * 100000) + '.json'));

    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, undefined, ' '));

    console.log("Config File Created!");
    console.table([
        {
            prefix,
            homeGuild
        }
    ]);

    if (!existsSync(path.join(__dirname, ".env"))) {
        const input = (await promptDefault("Generate a `.env' file? [y/N]: ", "n")).toLowerCase();

        if (input !== 'yes' && input !== 'y') {
            return;
        }

        const token = await promptLoop("What's your bot token? ", input => {
            if (input.trim() !== '' && input.indexOf(' ') === -1) {
                return true;
            }

            console.log("That's not a valid token.");
            return false;
        });

        const clientID = await promptLoop("What's your bot's client ID? ", snowflakeValidator);

        const mongoURI = await promptLoop("Enter the MongoDB URI for the bot to connect: ", input => {
            if (input.trim() !== '' && input.indexOf(' ') === -1) {
                return true;
            }

            console.log("That's not a valid MongoDB URI.");
            return false;
        });

        const jwtSecret = (await promptLoop("Enter a JWT secret key (hit enter to generate automatically): ", input => {
            if (input.trim() !== '') {
                return true;
            }

            console.log("That's not a valid secret.");
            return false;
        }, null)) ?? bcrypt.hashSync(Math.random() + '', bcrypt.genSaltSync());

        const webhook = await promptLoop("Enter a webhook URL for sending debug logs: ", input => {
            if (input.trim() !== '' && input.indexOf(' ') === -1) {
                return true;
            }

            console.log("That's not a valid webhook URL.");
            return false;
        });

        await fs.writeFile(path.join(__dirname, ".env"), `# Environment Configuration
        
        TOKEN=${token}
        ENV=dev
        CLIENT_ID=${clientID}
        GUILD_ID=${homeGuild}
        MONGO_URI=${mongoURI}
        JWT_SECRET=${jwtSecret}
        DEBUG_WEBHOOK_URL=${webhook}
        `);
        
        console.log("`.env` file generated successfully!");
    }

    rl.close();
})().catch(console.error);
1	rakinar2	577	#!/bin/node
2
3			/**
4			* setup.js -- the installer script
5			*
6			* This file is part of SudoBot.
7			*
8			* Copyright (C) 2021-2022 OSN Inc.
9			*
10			* SudoBot is free software; you can redistribute it and/or modify it
11			* under the terms of the GNU Affero General Public License as published by
12			* the Free Software Foundation, either version 3 of the License, or
13			* (at your option) any later version.
14			*
15			* SudoBot is distributed in the hope that it will be useful, but
16			* WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU Affero General Public License for more details.
19			*
20			* You should have received a copy of the GNU Affero General Public License
21			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
22			*/
23
24			const path = require('path');
25			const fs = require('fs/promises');
26			const readline = require('readline');
27			const bcrypt = require('bcrypt');
28
29			const CONFIG_DIR = path.resolve(__dirname, 'config');
30			const { version } = require('./package.json');
31			const { existsSync } = require('fs');
32			const SAMPLE_CONFIG_PATH = path.resolve(CONFIG_DIR, 'sample-config.json');
33			const CONFIG_PATH = path.resolve(CONFIG_DIR, 'config.json');
34
35			const isSnowflake = text => /^\d+$/.test(text);
36
37			const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
38
39			const prompt = text => new Promise(resolve => {
40			rl.question(text, resolve);
41			});
42
43			const promptDefault = async (text, defaultValue) => {
44			const input = await prompt(text);
45
46			if (input.toString().trim() === '') {
47			return defaultValue;
48			}
49
50			return input;
51			};
52
53			const promptLoop = async (text, validator, defaultValue) => {
54			let fn = promptDefault;
55
56			if (defaultValue === undefined) {
57			fn = prompt;
58			}
59
60			const input = await fn(text, defaultValue);
61
62			if (!(await validator(input ?? ''))) {
63			return promptLoop(text, validator, defaultValue);
64			}
65
66			return input ?? '';
67			};
68
69			const snowflakeValidator = input => {
70			if (!isSnowflake(input)) {
71			console.log(`That's not a valid snowflake! Please enter a valid ID.`);
72			return false;
73			}
74
75			return true;
76			};
77
78			(async () => {
79			console.log(`SudoBot version ${version}`);
80			console.log(`Copyright (C) OSN Inc 2022`);
81			console.log(`Thanks for using SudoBot! We'll much appreciate if you star the repository on GitHub.\n`);
82
83			let prefix = '-', homeGuild = '', owners = [];
84			let config = Object.entries(JSON.parse((await fs.readFile(SAMPLE_CONFIG_PATH)).toString()));
85
86			config[1][1].prefix = (await promptLoop(`What will be the bot prefix? [${prefix}]: `, input => {
87			if (input.trim().includes(' ')) {
88			console.log(`Prefixes must not contain spaces!`);
89			return false;
90			}
91
92			return true;
93			}, "-")).trim();
94
95			homeGuild = await promptLoop(`What will be the Home/Support Guild ID?: `, snowflakeValidator);
96			config[1][0] = homeGuild;
97
98			config = Object.fromEntries(config);
99
100			config.global.id = homeGuild;
101			config.global.owners = (await promptLoop(`Who will be the owner? Specify the owner user IDs separated with comma (,): `, input => {
102			const splitted = input.split(',');
103
104			for (const snowflake of splitted) {
105			if (!snowflakeValidator(snowflake)) {
106			console.log(`Invalid snowflake given! Make sure that the IDs are correctly given!`);
107			return false;
108			}
109			}
110
111			return true;
112			})).split(',').map(s => s.trim());
113
114			// config[1][0] = homeGuild;
115			// config[1][1].prefix = prefix;
116
117			// config.global.owners = owners;
118
119			const guildConfig = {...config[homeGuild]};
120
121			guildConfig.mod_role = await promptLoop(`What will be the moderator role ID?: `, snowflakeValidator);
122			guildConfig.admin = await promptLoop(`What will be the safe role ID?: `, snowflakeValidator);
123			guildConfig.mute_role = await promptLoop(`What will be the muted role ID?: `, snowflakeValidator);
124			guildConfig.gen_role = await promptLoop(`What will be the general role ID? [${homeGuild}]: `, snowflakeValidator, homeGuild);
125			guildConfig.logging_channel = await promptLoop(`What will be the main logging channel ID?: `, snowflakeValidator);
126			guildConfig.logging_channel_join_leave = await promptLoop(`What will be the join/leave logging channel ID?: `, snowflakeValidator);
127
128			config[homeGuild] = guildConfig;
129
130			console.log(config);
131
132			if (existsSync(CONFIG_PATH)) {
133			const input = await promptDefault("The config file (config/config.json) already exists. Do you want to overwrite the file? [y/N]: ", "n");
134
135			if (input.trim().toLowerCase() !== "y" && input.trim().toLowerCase() !== "yes") {
136			console.log("Aborting setup.");
137			rl.close();
138			process.exit(1);
139			}
140			}
141
142			if (existsSync(CONFIG_PATH))
143			await fs.rename(CONFIG_PATH, path.join(CONFIG_DIR, 'config-old-' + Math.round(Math.random() * 100000) + '.json'));
144
145			await fs.writeFile(CONFIG_PATH, JSON.stringify(config, undefined, ' '));
146
147			console.log("Config File Created!");
148			console.table([
149			{
150			prefix,
151			homeGuild
152			}
153			]);
154
155			if (!existsSync(path.join(__dirname, ".env"))) {
156			const input = (await promptDefault("Generate a `.env' file? [y/N]: ", "n")).toLowerCase();
157
158			if (input !== 'yes' && input !== 'y') {
159			return;
160			}
161
162			const token = await promptLoop("What's your bot token? ", input => {
163			if (input.trim() !== '' && input.indexOf(' ') === -1) {
164			return true;
165			}
166
167			console.log("That's not a valid token.");
168			return false;
169			});
170
171			const clientID = await promptLoop("What's your bot's client ID? ", snowflakeValidator);
172
173			const mongoURI = await promptLoop("Enter the MongoDB URI for the bot to connect: ", input => {
174			if (input.trim() !== '' && input.indexOf(' ') === -1) {
175			return true;
176			}
177
178			console.log("That's not a valid MongoDB URI.");
179			return false;
180			});
181
182			const jwtSecret = (await promptLoop("Enter a JWT secret key (hit enter to generate automatically): ", input => {
183			if (input.trim() !== '') {
184			return true;
185			}
186
187			console.log("That's not a valid secret.");
188			return false;
189			}, null)) ?? bcrypt.hashSync(Math.random() + '', bcrypt.genSaltSync());
190
191			const webhook = await promptLoop("Enter a webhook URL for sending debug logs: ", input => {
192			if (input.trim() !== '' && input.indexOf(' ') === -1) {
193			return true;
194			}
195
196			console.log("That's not a valid webhook URL.");
197			return false;
198			});
199
200			await fs.writeFile(path.join(__dirname, ".env"), `# Environment Configuration
201
202			TOKEN=${token}
203			ENV=dev
204			CLIENT_ID=${clientID}
205			GUILD_ID=${homeGuild}
206			MONGO_URI=${mongoURI}
207			JWT_SECRET=${jwtSecret}
208			DEBUG_WEBHOOK_URL=${webhook}
209			`);
210
211			console.log("`.env` file generated successfully!");
212			}
213
214			rl.close();
215			})().catch(console.error);