@budibase/cli 2.3.20 → 2.3.21-alpha.1

package/dist/hosting/init.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.init = void 0;
+const constants_1 = require("../constants");
+const questions_1 = require("../questions");
+const events_1 = require("../events");
+const makeFiles = __importStar(require("./makeFiles"));
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+const watch_1 = require("./watch");
+const genUser_1 = require("./genUser");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const DO_USER_DATA_URL = "http://169.254.169.254/metadata/v1/user-data";
+function getInitConfig(type, isQuick, port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = isQuick ? makeFiles.QUICK_CONFIG : {};
+        if (type === constants_1.InitType.DIGITAL_OCEAN) {
+            try {
+                const output = yield (0, node_fetch_1.default)(DO_USER_DATA_URL);
+                const data = yield output.text();
+                const response = (0, utils_1.parseEnv)(data);
+                for (let [key, value] of Object.entries(makeFiles.ConfigMap)) {
+                    if (response[key]) {
+                        config[value] = response[key];
+                    }
+                }
+            }
+            catch (err) {
+                // don't need to handle error, just don't do anything
+            }
+        }
+        // override port
+        if (port) {
+            config[makeFiles.ConfigMap.MAIN_PORT] = port;
+        }
+        return config;
+    });
+}
+function init(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let type, isSingle, watchDir, genUser, port, silent;
+        if (typeof opts === "string") {
+            type = opts;
+        }
+        else {
+            type = opts["init"];
+            isSingle = opts["single"];
+            watchDir = opts["watchPluginDir"];
+            genUser = opts["genUser"];
+            port = opts["port"];
+            silent = opts["silent"];
+        }
+        const isQuick = type === constants_1.InitType.QUICK || type === constants_1.InitType.DIGITAL_OCEAN;
+        yield (0, utils_2.checkDockerConfigured)();
+        if (!isQuick) {
+            const shouldContinue = yield (0, questions_1.confirmation)("This will create multiple files in current directory, should continue?");
+            if (!shouldContinue) {
+                console.log("Stopping.");
+                return;
+            }
+        }
+        (0, events_1.captureEvent)(constants_1.AnalyticsEvent.SelfHostInit, {
+            type,
+        });
+        const config = yield getInitConfig(type, isQuick, port);
+        if (!isSingle) {
+            yield (0, utils_2.downloadDockerCompose)();
+            yield makeFiles.makeEnv(config, silent);
+        }
+        else {
+            yield makeFiles.makeSingleCompose(config, silent);
+        }
+        if (watchDir) {
+            yield (0, watch_1.watchPlugins)(watchDir, silent);
+        }
+        if (genUser) {
+            const inputPassword = typeof genUser === "string" ? genUser : null;
+            yield (0, genUser_1.generateUser)(inputPassword, silent);
+        }
+    });
+}
+exports.init = init;

package/dist/hosting/makeFiles.js

@@ -0,0 +1,143 @@
+"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.getComposeProperty = exports.getEnvProperty = exports.makeSingleCompose = exports.makeEnv = exports.QUICK_CONFIG = exports.ConfigMap = exports.ENV_PATH = exports.COMPOSE_PATH = void 0;
+const questions_1 = require("../questions");
+const utils_1 = require("../utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const utils_2 = require("./utils");
+const randomString = require("randomstring");
+const SINGLE_IMAGE = "budibase/budibase:latest";
+const VOL_NAME = "budibase_data";
+exports.COMPOSE_PATH = path_1.default.resolve("./docker-compose.yaml");
+exports.ENV_PATH = path_1.default.resolve("./.env");
+function getSecrets(opts = { single: false }) {
+    const secrets = [
+        "JWT_SECRET",
+        "MINIO_ACCESS_KEY",
+        "MINIO_SECRET_KEY",
+        "REDIS_PASSWORD",
+        "INTERNAL_API_KEY",
+    ];
+    const obj = {};
+    secrets.forEach(secret => (obj[secret] = randomString.generate()));
+    // setup couch creds separately
+    if (opts && opts.single) {
+        obj["COUCHDB_USER"] = "admin";
+        obj["COUCHDB_PASSWORD"] = randomString.generate();
+    }
+    else {
+        obj["COUCH_DB_USER"] = "admin";
+        obj["COUCH_DB_PASSWORD"] = randomString.generate();
+    }
+    return obj;
+}
+function getSingleCompose(port) {
+    const singleComposeObj = {
+        version: "3",
+        services: {
+            budibase: {
+                restart: "unless-stopped",
+                image: SINGLE_IMAGE,
+                ports: [`${port}:80`],
+                environment: getSecrets({ single: true }),
+                volumes: [`${VOL_NAME}:/data`],
+            },
+        },
+        volumes: {
+            [VOL_NAME]: {
+                driver: "local",
+            },
+        },
+    };
+    return yaml_1.default.stringify(singleComposeObj);
+}
+function getEnv(port) {
+    const partOne = (0, utils_1.stringifyToDotEnv)({
+        MAIN_PORT: port,
+    });
+    const partTwo = (0, utils_1.stringifyToDotEnv)(getSecrets());
+    const partThree = (0, utils_1.stringifyToDotEnv)({
+        APP_PORT: 4002,
+        WORKER_PORT: 4003,
+        MINIO_PORT: 4004,
+        COUCH_DB_PORT: 4005,
+        REDIS_PORT: 6379,
+        WATCHTOWER_PORT: 6161,
+        BUDIBASE_ENVIRONMENT: "PRODUCTION",
+    });
+    return [
+        "# Use the main port in the builder for your self hosting URL, e.g. localhost:10000",
+        partOne,
+        "# This section contains all secrets pertaining to the system",
+        partTwo,
+        "# This section contains variables that do not need to be altered under normal circumstances",
+        partThree,
+    ].join("\n");
+}
+exports.ConfigMap = {
+    MAIN_PORT: "port",
+};
+exports.QUICK_CONFIG = {
+    key: "budibase",
+    port: 10000,
+};
+function make(path, contentsFn, inputs = {}, silent) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const port = inputs.port ||
+            (yield (0, questions_1.number)("Please enter the port on which you want your installation to run: ", 10000));
+        const fileContents = contentsFn(port);
+        fs_1.default.writeFileSync(path, fileContents);
+        if (!silent) {
+            console.log((0, utils_1.success)(`Configuration has been written successfully - please check ${path} for more details.`));
+        }
+    });
+}
+function makeEnv(inputs = {}, silent) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return make(exports.ENV_PATH, getEnv, inputs, silent);
+    });
+}
+exports.makeEnv = makeEnv;
+function makeSingleCompose(inputs = {}, silent) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return make(exports.COMPOSE_PATH, getSingleCompose, inputs, silent);
+    });
+}
+exports.makeSingleCompose = makeSingleCompose;
+function getEnvProperty(property) {
+    const props = fs_1.default.readFileSync(exports.ENV_PATH, "utf8").split(property);
+    if (props[0].charAt(0) === "=") {
+        property = props[0];
+    }
+    else {
+        property = props[1];
+    }
+    return property.split("=")[1].split("\n")[0];
+}
+exports.getEnvProperty = getEnvProperty;
+function getComposeProperty(property) {
+    const { service } = (0, utils_2.getAppService)(exports.COMPOSE_PATH);
+    if (property === "port" && Array.isArray(service.ports)) {
+        const port = service.ports[0];
+        return port.split(":")[0];
+    }
+    else if (service.environment) {
+        return service.environment[property];
+    }
+    return null;
+}
+exports.getComposeProperty = getComposeProperty;

package/dist/hosting/start.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.start = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const makeFiles = __importStar(require("./makeFiles"));
+const docker_compose_1 = __importDefault(require("docker-compose"));
+const fs_1 = __importDefault(require("fs"));
+function start() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, utils_1.checkDockerConfigured)();
+        (0, utils_1.checkInitComplete)();
+        console.log((0, utils_2.info)("Starting services, this may take a moment - first time this may take a few minutes to download images."));
+        let port;
+        if (fs_1.default.existsSync(makeFiles.ENV_PATH)) {
+            port = makeFiles.getEnvProperty("MAIN_PORT");
+        }
+        else {
+            port = makeFiles.getComposeProperty("port");
+        }
+        yield (0, utils_1.handleError)(() => __awaiter(this, void 0, void 0, function* () {
+            // need to log as it makes it more clear
+            yield docker_compose_1.default.upAll({ cwd: "./", log: true });
+        }));
+        console.log((0, utils_2.success)(`Services started, please go to http://localhost:${port} for next steps.`));
+    });
+}
+exports.start = start;

package/dist/hosting/status.js

@@ -0,0 +1,30 @@
+"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.status = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const docker_compose_1 = __importDefault(require("docker-compose"));
+function status() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, utils_1.checkDockerConfigured)();
+        (0, utils_1.checkInitComplete)();
+        console.log((0, utils_2.info)("Budibase status"));
+        yield (0, utils_1.handleError)(() => __awaiter(this, void 0, void 0, function* () {
+            const response = yield docker_compose_1.default.ps();
+            console.log(response.out);
+        }));
+    });
+}
+exports.status = status;

package/dist/hosting/stop.js

@@ -0,0 +1,30 @@
+"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.stop = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const docker_compose_1 = __importDefault(require("docker-compose"));
+function stop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, utils_1.checkDockerConfigured)();
+        (0, utils_1.checkInitComplete)();
+        console.log((0, utils_2.info)("Stopping services, this may take a moment."));
+        yield (0, utils_1.handleError)(() => __awaiter(this, void 0, void 0, function* () {
+            yield docker_compose_1.default.stop();
+        }));
+        console.log((0, utils_2.success)("Services have been stopped successfully."));
+    });
+}
+exports.stop = stop;

package/dist/hosting/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hosting/update.js

@@ -0,0 +1,58 @@
+"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.update = void 0;
+const utils_1 = require("./utils");
+const questions_1 = require("../questions");
+const docker_compose_1 = __importDefault(require("docker-compose"));
+const makeFiles_1 = require("./makeFiles");
+const utils_2 = require("../utils");
+const start_1 = require("./start");
+const BB_COMPOSE_SERVICES = ["app-service", "worker-service", "proxy-service"];
+const BB_SINGLE_SERVICE = ["budibase"];
+function update() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { services } = (0, utils_1.getServices)(makeFiles_1.COMPOSE_PATH);
+        const isSingle = Object.keys(services).length === 1;
+        yield (0, utils_1.checkDockerConfigured)();
+        (0, utils_1.checkInitComplete)();
+        if (!isSingle &&
+            (yield (0, questions_1.confirmation)("Do you wish to update you docker-compose.yaml?"))) {
+            yield (0, utils_1.downloadDockerCompose)();
+        }
+        yield (0, utils_1.handleError)(() => __awaiter(this, void 0, void 0, function* () {
+            const status = yield docker_compose_1.default.ps();
+            const parts = status.out.split("\n");
+            const isUp = parts[2] && parts[2].indexOf("Up") !== -1;
+            if (isUp) {
+                console.log((0, utils_2.info)("Stopping services, this may take a moment."));
+                yield docker_compose_1.default.stop();
+            }
+            console.log((0, utils_2.info)("Beginning update, this may take a few minutes."));
+            let services;
+            if (isSingle) {
+                services = BB_SINGLE_SERVICE;
+            }
+            else {
+                services = BB_COMPOSE_SERVICES;
+            }
+            yield docker_compose_1.default.pullMany(services, { log: true });
+            if (isUp) {
+                console.log((0, utils_2.success)("Update complete, restarting services..."));
+                yield (0, start_1.start)();
+            }
+        }));
+    });
+}
+exports.update = update;

package/dist/hosting/utils.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.updateDockerComposeService = exports.getAppService = exports.getServices = exports.handleError = exports.checkInitComplete = exports.checkDockerConfigured = exports.downloadDockerCompose = void 0;
+const lookpath_1 = require("lookpath");
+const fs_1 = __importDefault(require("fs"));
+const makeFiles = __importStar(require("./makeFiles"));
+const utils_1 = require("../utils");
+const yaml_1 = __importDefault(require("yaml"));
+const ERROR_FILE = "docker-error.log";
+const COMPOSE_URL = "https://raw.githubusercontent.com/Budibase/budibase/master/hosting/docker-compose.yaml";
+function downloadDockerCompose() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileName = COMPOSE_URL.split("/").slice(-1)[0];
+        try {
+            yield (0, utils_1.downloadFile)(COMPOSE_URL, `./${fileName}`);
+        }
+        catch (err) {
+            console.error((0, utils_1.error)(`Failed to retrieve compose file - ${err}`));
+        }
+    });
+}
+exports.downloadDockerCompose = downloadDockerCompose;
+function checkDockerConfigured() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const error = "docker/docker-compose has not been installed, please follow instructions at: https://docs.budibase.com/docs/docker-compose";
+        const docker = yield (0, lookpath_1.lookpath)("docker");
+        const compose = yield (0, lookpath_1.lookpath)("docker-compose");
+        if (!docker || !compose) {
+            throw error;
+        }
+    });
+}
+exports.checkDockerConfigured = checkDockerConfigured;
+function checkInitComplete() {
+    if (!fs_1.default.existsSync(makeFiles.ENV_PATH) &&
+        !fs_1.default.existsSync(makeFiles.COMPOSE_PATH)) {
+        throw "Please run the hosting --init command before any other hosting command.";
+    }
+}
+exports.checkInitComplete = checkInitComplete;
+function handleError(func) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield func();
+        }
+        catch (err) {
+            if (err && err.err) {
+                (0, utils_1.logErrorToFile)(ERROR_FILE, err.err);
+            }
+            throw `Failed to start - logs written to file: ${ERROR_FILE}`;
+        }
+    });
+}
+exports.handleError = handleError;
+function getServices(path) {
+    const dockerYaml = fs_1.default.readFileSync(path, "utf8");
+    const parsedYaml = yaml_1.default.parse(dockerYaml);
+    return { yaml: parsedYaml, services: parsedYaml.services };
+}
+exports.getServices = getServices;
+function getAppService(path) {
+    const { yaml, services } = getServices(path), serviceList = Object.keys(services);
+    let service;
+    if (services["app-service"]) {
+        service = services["app-service"];
+    }
+    else if (serviceList.length === 1) {
+        service = services[serviceList[0]];
+    }
+    return { yaml, service };
+}
+exports.getAppService = getAppService;
+function updateDockerComposeService(
+// eslint-disable-next-line no-unused-vars
+updateFn) {
+    const opts = ["docker-compose.yaml", "docker-compose.yml"];
+    const dockerFilePath = opts.find(name => fs_1.default.existsSync(name));
+    if (!dockerFilePath) {
+        console.log((0, utils_1.error)("Unable to locate docker-compose YAML."));
+        return;
+    }
+    const { yaml: parsedYaml, service } = getAppService(dockerFilePath);
+    if (!service) {
+        console.log((0, utils_1.error)("Unable to locate service within compose file, is it a valid Budibase configuration?"));
+        return;
+    }
+    updateFn(service);
+    fs_1.default.writeFileSync(dockerFilePath, yaml_1.default.stringify(parsedYaml));
+}
+exports.updateDockerComposeService = updateDockerComposeService;

package/dist/hosting/watch.js

@@ -0,0 +1,47 @@
+"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.watchPlugins = void 0;
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+function watchPlugins(pluginPath, silent) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const PLUGIN_PATH = "/plugins";
+        // get absolute path
+        pluginPath = (0, path_1.resolve)(pluginPath);
+        if (!fs_1.default.existsSync(pluginPath)) {
+            console.log((0, utils_1.error)(`The directory "${pluginPath}" does not exist, please create and then try again.`));
+            return;
+        }
+        (0, utils_2.updateDockerComposeService)((service) => {
+            // set environment variable
+            service.environment["PLUGINS_DIR"] = PLUGIN_PATH;
+            // add volumes to parsed yaml
+            if (!service.volumes) {
+                service.volumes = [];
+            }
+            const found = service.volumes.find(vol => vol.includes(PLUGIN_PATH));
+            if (found) {
+                service.volumes.splice(service.volumes.indexOf(found), 1);
+            }
+            service.volumes.push(`${pluginPath}:${PLUGIN_PATH}`);
+        });
+        if (!silent) {
+            console.log((0, utils_1.success)(`Docker compose configured to watch directory: ${pluginPath}`));
+        }
+    });
+}
+exports.watchPlugins = watchPlugins;

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"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 });
+require("./prebuilds");
+require("./environment");
+const options_1 = require("./options");
+const commander_1 = require("commander");
+const utils_1 = require("./utils");
+const json = require("../package.json");
+// add hosting config
+function init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const program = new commander_1.Command()
+            .addHelpCommand("help", (0, utils_1.getHelpDescription)("Help with Budibase commands."))
+            .helpOption(false)
+            .version(json.version);
+        // add commands
+        for (let command of (0, options_1.getCommands)()) {
+            command.configure(program);
+        }
+        // this will stop the program if no command found
+        yield program.parseAsync(process.argv);
+    });
+}
+init().catch(err => {
+    console.error(`Unexpected error - `, err);
+});

package/dist/options.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommands = void 0;
+const analytics_1 = __importDefault(require("./analytics"));
+const hosting_1 = __importDefault(require("./hosting"));
+const backups_1 = __importDefault(require("./backups"));
+const plugins_1 = __importDefault(require("./plugins"));
+function getCommands() {
+    return [hosting_1.default, analytics_1.default, backups_1.default, plugins_1.default];
+}
+exports.getCommands = getCommands;