@budibase/cli 2.3.18-alpha.3 → 2.3.18-alpha.30

package/dist/analytics/Client.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsClient = void 0;
+const posthog_node_1 = __importDefault(require("posthog-node"));
+const constants_1 = require("../constants");
+const ConfigManager_1 = require("../structures/ConfigManager");
+class AnalyticsClient {
+    constructor() {
+        this.client = new posthog_node_1.default(constants_1.POSTHOG_TOKEN, {});
+        this.configManager = new ConfigManager_1.ConfigManager();
+    }
+    capture(event) {
+        if (this.configManager.config.analyticsDisabled)
+            return;
+        this.client.capture(event);
+    }
+    enable() {
+        this.configManager.removeKey("analyticsDisabled");
+        this.client.capture({ event: constants_1.AnalyticsEvent.OptIn, distinctId: "cli" });
+    }
+    disable() {
+        this.client.capture({ event: constants_1.AnalyticsEvent.OptOut, distinctId: "cli" });
+        this.configManager.setValue("analyticsDisabled", true);
+    }
+    status() {
+        return this.configManager.config.analyticsDisabled ? "disabled" : "enabled";
+    }
+}
+exports.AnalyticsClient = AnalyticsClient;

package/dist/analytics/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("../structures/Command");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const Client_1 = require("./Client");
+const client = new Client_1.AnalyticsClient();
+function optOut() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // opt them out
+            client.disable();
+            console.log((0, utils_1.success)("Successfully opted out of Budibase analytics. You can opt in at any time by running 'budi analytics opt-in'"));
+        }
+        catch (err) {
+            console.log((0, utils_1.error)(`Error opting out of Budibase analytics. Please try again later - ${err}`));
+        }
+    });
+}
+function optIn() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // opt them in
+            client.enable();
+            console.log((0, utils_1.success)("Successfully opted in to Budibase analytics. Thank you for helping us make Budibase better!"));
+        }
+        catch (err) {
+            console.log((0, utils_1.error)("Error opting in to Budibase analytics. Please try again later."));
+        }
+    });
+}
+function status() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log((0, utils_1.success)(`Budibase analytics ${client.status()}`));
+        }
+        catch (err) {
+            console.log((0, utils_1.error)("Error fetching analytics status. Please try again later."));
+        }
+    });
+}
+exports.default = new Command_1.Command(`${constants_1.CommandWord.ANALYTICS}`)
+    .addHelp("Control the analytics you send to Budibase.")
+    .addSubOption("--optin", "Opt in to sending analytics to Budibase", optIn)
+    .addSubOption("--optout", "Opt out of sending analytics to Budibase.", optOut)
+    .addSubOption("--status", "Check whether you are currently opted in to Budibase analytics.", status);

package/dist/backups/index.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("../structures/Command");
+const constants_1 = require("../constants");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const db_1 = require("../core/db");
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+const objectStore_1 = require("./objectStore");
+const tar = require("tar");
+function exportBackup(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const envFile = opts.env || undefined;
+        let filename = opts["export"] || opts;
+        if (typeof filename !== "string") {
+            filename = `backup-${new Date().toISOString()}.tar.gz`;
+        }
+        const config = yield (0, utils_2.getConfig)(envFile);
+        const dbList = (yield (0, db_1.getAllDbs)(config["COUCH_DB_URL"]));
+        const { Remote, Local } = (0, utils_2.getPouches)(config);
+        if (fs_1.default.existsSync(utils_2.TEMP_DIR)) {
+            fs_1.default.rmSync(utils_2.TEMP_DIR, { recursive: true });
+        }
+        const couchDir = (0, path_1.join)(utils_2.TEMP_DIR, utils_2.COUCH_DIR);
+        fs_1.default.mkdirSync(utils_2.TEMP_DIR);
+        fs_1.default.mkdirSync(couchDir);
+        console.log("CouchDB Export");
+        const bar = (0, utils_1.progressBar)(dbList.length);
+        let count = 0;
+        for (let db of dbList) {
+            bar.update(++count);
+            const remote = new Remote(db);
+            const local = new Local((0, path_1.join)(utils_2.TEMP_DIR, utils_2.COUCH_DIR, db));
+            yield (0, utils_2.replication)(remote, local);
+        }
+        bar.stop();
+        console.log("S3 Export");
+        yield (0, objectStore_1.exportObjects)();
+        tar.create({
+            sync: true,
+            gzip: true,
+            file: filename,
+            cwd: (0, path_1.join)(utils_2.TEMP_DIR),
+        }, [utils_2.COUCH_DIR, utils_2.MINIO_DIR]);
+        fs_1.default.rmSync(utils_2.TEMP_DIR, { recursive: true });
+        console.log(`Generated export file - ${filename}`);
+    });
+}
+function importBackup(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const envFile = opts.env || undefined;
+        const filename = opts["import"] || opts;
+        const config = yield (0, utils_2.getConfig)(envFile);
+        if (!filename || !fs_1.default.existsSync(filename)) {
+            console.error("Cannot import without specifying a valid file to import");
+            process.exit(-1);
+        }
+        if (fs_1.default.existsSync(utils_2.TEMP_DIR)) {
+            fs_1.default.rmSync(utils_2.TEMP_DIR, { recursive: true });
+        }
+        fs_1.default.mkdirSync(utils_2.TEMP_DIR);
+        tar.extract({
+            sync: true,
+            cwd: (0, path_1.join)(utils_2.TEMP_DIR),
+            file: filename,
+        });
+        const { Remote, Local } = (0, utils_2.getPouches)(config);
+        const dbList = fs_1.default.readdirSync((0, path_1.join)(utils_2.TEMP_DIR, utils_2.COUCH_DIR));
+        console.log("CouchDB Import");
+        const bar = (0, utils_1.progressBar)(dbList.length);
+        let count = 0;
+        for (let db of dbList) {
+            bar.update(++count);
+            const remote = new Remote(db);
+            const local = new Local((0, path_1.join)(utils_2.TEMP_DIR, utils_2.COUCH_DIR, db));
+            yield (0, utils_2.replication)(local, remote);
+        }
+        bar.stop();
+        console.log("MinIO Import");
+        yield (0, objectStore_1.importObjects)();
+        // finish by letting the system know that a restore has occurred
+        try {
+            yield (0, utils_1.httpCall)(`http://localhost:${config.MAIN_PORT}/api/system/restored`, "POST");
+        }
+        catch (err) {
+            // ignore error - it will be an older system
+        }
+        console.log("Import complete");
+        fs_1.default.rmSync(utils_2.TEMP_DIR, { recursive: true });
+    });
+}
+function pickOne(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (opts["import"]) {
+            return importBackup(opts);
+        }
+        else if (opts["export"]) {
+            return exportBackup(opts);
+        }
+    });
+}
+exports.default = new Command_1.Command(`${constants_1.CommandWord.BACKUPS}`)
+    .addHelp("Allows building backups of Budibase, as well as importing a backup to a new instance.")
+    .addSubOption("--export [filename]", "Export a backup from an existing Budibase installation.", exportBackup)
+    .addSubOption("--import [filename]", "Import a backup to a new Budibase installation.", importBackup)
+    .addSubOption("--env [envFile]", "Provide an environment variable file to configure the CLI.", pickOne);

package/dist/backups/objectStore.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importObjects = exports.exportObjects = void 0;
+const backend_core_1 = require("@budibase/backend-core");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const { ObjectStoreBuckets, ObjectStore, retrieve, uploadDirectory, makeSureBucketExists, } = backend_core_1.objectStore;
+const bucketList = Object.values(ObjectStoreBuckets);
+function exportObjects() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = (0, path_1.join)(utils_1.TEMP_DIR, utils_1.MINIO_DIR);
+        fs_1.default.mkdirSync(path);
+        let fullList = [];
+        let errorCount = 0;
+        for (let bucket of bucketList) {
+            const client = ObjectStore(bucket);
+            try {
+                yield client.headBucket().promise();
+            }
+            catch (err) {
+                errorCount++;
+                continue;
+            }
+            const list = (yield client.listObjectsV2().promise());
+            fullList = fullList.concat(list.Contents.map(el => (Object.assign(Object.assign({}, el), { bucket }))));
+        }
+        if (errorCount === bucketList.length) {
+            throw new Error("Unable to access MinIO/S3 - check environment config.");
+        }
+        const bar = (0, utils_2.progressBar)(fullList.length);
+        let count = 0;
+        for (let object of fullList) {
+            const filename = object.Key;
+            const data = yield retrieve(object.bucket, filename);
+            const possiblePath = filename.split("/");
+            if (possiblePath.length > 1) {
+                const dirs = possiblePath.slice(0, possiblePath.length - 1);
+                fs_1.default.mkdirSync((0, path_1.join)(path, object.bucket, ...dirs), { recursive: true });
+            }
+            fs_1.default.writeFileSync((0, path_1.join)(path, object.bucket, ...possiblePath), data);
+            bar.update(++count);
+        }
+        bar.stop();
+    });
+}
+exports.exportObjects = exportObjects;
+function importObjects() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = (0, path_1.join)(utils_1.TEMP_DIR, utils_1.MINIO_DIR);
+        const buckets = fs_1.default.readdirSync(path);
+        let total = 0;
+        buckets.forEach(bucket => {
+            const files = fs_1.default.readdirSync((0, path_1.join)(path, bucket));
+            total += files.length;
+        });
+        const bar = (0, utils_2.progressBar)(total);
+        let count = 0;
+        for (let bucket of buckets) {
+            const client = ObjectStore(bucket);
+            yield makeSureBucketExists(client, bucket);
+            const files = yield uploadDirectory(bucket, (0, path_1.join)(path, bucket), "/");
+            count += files.length;
+            bar.update(count);
+        }
+        bar.stop();
+    });
+}
+exports.importObjects = importObjects;

package/dist/backups/utils.js

@@ -0,0 +1,110 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPouches = exports.replication = exports.getConfig = exports.loadEnvironment = exports.askQuestions = exports.checkURLs = exports.MINIO_DIR = exports.COUCH_DIR = exports.TEMP_DIR = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const questions_1 = require("../questions");
+const db_1 = require("../core/db");
+const backend_core_1 = require("@budibase/backend-core");
+exports.TEMP_DIR = ".temp";
+exports.COUCH_DIR = "couchdb";
+exports.MINIO_DIR = "minio";
+const REQUIRED = [
+    { value: "MAIN_PORT", default: "10000" },
+    {
+        value: "COUCH_DB_URL",
+        default: "http://budibase:budibase@localhost:10000/db/",
+    },
+    { value: "MINIO_URL", default: "http://localhost:10000" },
+    { value: "MINIO_ACCESS_KEY" },
+    { value: "MINIO_SECRET_KEY" },
+];
+function checkURLs(config) {
+    const mainPort = config["MAIN_PORT"], username = config["COUCH_DB_USER"], password = config["COUCH_DB_PASSWORD"];
+    if (!config["COUCH_DB_URL"] && mainPort && username && password) {
+        config["COUCH_DB_URL"] = `http://${username}:${password}@localhost:${mainPort}/db/`;
+    }
+    if (!config["MINIO_URL"]) {
+        config["MINIO_URL"] = `http://localhost:${mainPort}/`;
+    }
+    return config;
+}
+exports.checkURLs = checkURLs;
+function askQuestions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("*** NOTE: use a .env file to load these parameters repeatedly ***");
+        let config = {};
+        for (let property of REQUIRED) {
+            config[property.value] = yield (0, questions_1.string)(property.value, property.default);
+        }
+        return config;
+    });
+}
+exports.askQuestions = askQuestions;
+function loadEnvironment(path) {
+    if (!fs_1.default.existsSync(path)) {
+        throw "Unable to file specified .env file";
+    }
+    const env = fs_1.default.readFileSync(path, "utf8");
+    const config = checkURLs(dotenv_1.default.parse(env));
+    for (let required of REQUIRED) {
+        if (!config[required.value]) {
+            throw `Cannot find "${required.value}" property in .env file`;
+        }
+    }
+    return config;
+}
+exports.loadEnvironment = loadEnvironment;
+// true is the default value passed by commander
+function getConfig(envFile = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let config;
+        if (envFile !== true) {
+            config = loadEnvironment(envFile);
+        }
+        else {
+            config = yield askQuestions();
+        }
+        // fill out environment
+        for (let key of Object.keys(config)) {
+            backend_core_1.env._set(key, config[key]);
+        }
+        return config;
+    });
+}
+exports.getConfig = getConfig;
+function replication(from, to) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pouch = (0, db_1.getPouch)();
+        try {
+            yield pouch.replicate(from, to, {
+                batch_size: 1000,
+                batches_limit: 5,
+                // @ts-ignore
+                style: "main_only",
+            });
+        }
+        catch (err) {
+            throw new Error(`Replication failed - ${JSON.stringify(err)}`);
+        }
+    });
+}
+exports.replication = replication;
+function getPouches(config) {
+    const Remote = (0, db_1.getPouch)(config["COUCH_DB_URL"]);
+    const Local = (0, db_1.getPouch)();
+    return { Remote, Local };
+}
+exports.getPouches = getPouches;

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATED_USER_EMAIL = exports.POSTHOG_TOKEN = exports.AnalyticsEvent = exports.InitType = exports.CommandWord = void 0;
+var types_1 = require("@budibase/types");
+Object.defineProperty(exports, "CommandWord", { enumerable: true, get: function () { return types_1.CommandWord; } });
+Object.defineProperty(exports, "InitType", { enumerable: true, get: function () { return types_1.InitType; } });
+Object.defineProperty(exports, "AnalyticsEvent", { enumerable: true, get: function () { return types_1.AnalyticsEvent; } });
+exports.POSTHOG_TOKEN = "phc_yGOn4i7jWKaCTapdGR6lfA4AvmuEQ2ijn5zAVSFYPlS";
+exports.GENERATED_USER_EMAIL = "admin@admin.com";

package/dist/core/db.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllDbs = exports.getPouch = void 0;
+const pouchdb_1 = __importDefault(require("pouchdb"));
+const utils_1 = require("../utils");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+/**
+ * Fully qualified URL including username and password, or nothing for local
+ */
+function getPouch(url) {
+    let POUCH_DB_DEFAULTS;
+    if (!url) {
+        POUCH_DB_DEFAULTS = {
+            prefix: undefined,
+            adapter: "leveldb",
+        };
+    }
+    else {
+        POUCH_DB_DEFAULTS = {
+            prefix: url,
+        };
+    }
+    const replicationStream = require("pouchdb-replication-stream");
+    pouchdb_1.default.plugin(replicationStream.plugin);
+    // @ts-ignore
+    pouchdb_1.default.adapter("writableStream", replicationStream.adapters.writableStream);
+    return pouchdb_1.default.defaults(POUCH_DB_DEFAULTS);
+}
+exports.getPouch = getPouch;
+function getAllDbs(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)((0, utils_1.checkSlashesInUrl)(encodeURI(`${url}/_all_dbs`)), {
+            method: "GET",
+        });
+        if (response.status === 200) {
+            return yield response.json();
+        }
+        else {
+            throw "Cannot connect to CouchDB instance";
+        }
+    });
+}
+exports.getAllDbs = getAllDbs;

package/dist/environment.js

@@ -0,0 +1,4 @@
+"use strict";
+process.env.NO_JS = "1";
+process.env.JS_BCRYPT = "1";
+process.env.DISABLE_JWT_WARNING = "1";

package/dist/events.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureEvent = void 0;
+const Client_1 = require("./analytics/Client");
+const client = new Client_1.AnalyticsClient();
+function captureEvent(event, properties) {
+    client.capture({
+        distinctId: "cli",
+        event,
+        properties,
+    });
+}
+exports.captureEvent = captureEvent;

package/dist/exec.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPkgCommand = exports.utilityInstalled = exports.exec = void 0;
+const util_1 = __importDefault(require("util"));
+const runCommand = util_1.default.promisify(require("child_process").exec);
+function exec(command, dir = "./") {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { stdout } = yield runCommand(command, { cwd: dir });
+        return stdout;
+    });
+}
+exports.exec = exec;
+function utilityInstalled(utilName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield exec(`${utilName} --version`);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    });
+}
+exports.utilityInstalled = utilityInstalled;
+function runPkgCommand(command, dir = "./") {
+    return __awaiter(this, void 0, void 0, function* () {
+        const yarn = yield exports.utilityInstalled("yarn");
+        const npm = yield exports.utilityInstalled("npm");
+        if (!yarn && !npm) {
+            throw new Error("Must have yarn or npm installed to run build.");
+        }
+        const npmCmd = command === "install" ? `npm ${command}` : `npm run ${command}`;
+        const cmd = yarn ? `yarn ${command} --ignore-engines` : npmCmd;
+        yield exports.exec(cmd, dir);
+    });
+}
+exports.runPkgCommand = runPkgCommand;

package/dist/hosting/genUser.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUser = void 0;
+const { success } = require("../utils");
+const { updateDockerComposeService } = require("./utils");
+const randomString = require("randomstring");
+const { GENERATED_USER_EMAIL } = require("../constants");
+function generateUser(password, silent) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const email = GENERATED_USER_EMAIL;
+        if (!password) {
+            password = randomString.generate({ length: 6 });
+        }
+        updateDockerComposeService((service) => {
+            service.environment["BB_ADMIN_USER_EMAIL"] = email;
+            service.environment["BB_ADMIN_USER_PASSWORD"] = password;
+        });
+        if (!silent) {
+            console.log(success(`User admin credentials configured, access with email: ${email} - password: ${password}`));
+        }
+    });
+}
+exports.generateUser = generateUser;

package/dist/hosting/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("../structures/Command");
+const constants_1 = require("../constants");
+const init_1 = require("./init");
+const start_1 = require("./start");
+const stop_1 = require("./stop");
+const status_1 = require("./status");
+const update_1 = require("./update");
+const genUser_1 = require("./genUser");
+const watch_1 = require("./watch");
+exports.default = new Command_1.Command(`${constants_1.CommandWord.HOSTING}`)
+    .addHelp("Controls self hosting on the Budibase platform.")
+    .addSubOption("--init [type]", "Configure a self hosted platform in current directory, type can be unspecified, 'quick' or 'single'.", init_1.init)
+    .addSubOption("--start", "Start the configured platform in current directory.", start_1.start)
+    .addSubOption("--status", "Check the status of currently running services.", status_1.status)
+    .addSubOption("--stop", "Stop the configured platform in the current directory.", stop_1.stop)
+    .addSubOption("--update", "Update the Budibase images to the latest version.", update_1.update)
+    .addSubOption("--watch-plugin-dir [directory]", "Add plugin directory watching to a Budibase install.", watch_1.watchPlugins)
+    .addSubOption("--gen-user", "Create an admin user automatically as part of first start.", genUser_1.generateUser)
+    .addSubOption("--single", "Specify this with init to use the single image.");