@govuk-pay/cli 0.0.30 → 0.0.31

package/src/commands/local/config/pay_local_cluster.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadClusterConfig = exports.PayLocalCluster = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const md5_js_1 = require("../../../util/md5.js");
+// This is the complete cluster configuration that will be used as the context for template rendering
+class PayLocalCluster {
+    name;
+    payServices;
+    dbServices;
+    reverseProxyServices;
+    egressProxy;
+    javaApps;
+    nodeApps;
+    localJavaApps;
+    localNodeApps;
+    remoteJavaApps;
+    remoteNodeApps;
+    anyJavaApps;
+    anyNodeApps;
+    workspace;
+    requiresLocalStack;
+    requiresRedis;
+    requiresEgressProxy;
+    serviceURLEnvVars;
+    mountLocalNodeApps;
+    noProxyEnvVar;
+    defaultServiceConfigsPath;
+    environmentOverridesPath;
+    constructor(clusterConfig) {
+        this.name = clusterConfig.name;
+        this.workspace = clusterConfig.workspace;
+        this.payServices = clusterConfig.payServices;
+        this.dbServices = clusterConfig.dbServices;
+        this.reverseProxyServices = clusterConfig.reverseProxyServices;
+        this.egressProxy = clusterConfig.egressProxy;
+        this.javaApps = this.payServices.filter((service) => service.serviceType === PayServiceType.Java);
+        this.nodeApps = this.payServices.filter((service) => service.serviceType === PayServiceType.Node);
+        this.remoteJavaApps = this.javaApps.filter((service) => service.localBuild);
+        this.remoteNodeApps = this.nodeApps.filter((service) => service.localBuild);
+        this.localJavaApps = this.javaApps.filter((service) => service.localBuild);
+        this.localNodeApps = this.nodeApps.filter((service) => service.localBuild);
+        this.anyJavaApps = this.javaApps.length >= 0;
+        this.anyNodeApps = this.nodeApps.length >= 0;
+        this.requiresLocalStack = this.payServices.some((service) => service.requiresLocalStack);
+        this.requiresRedis = this.payServices.some((service) => service.usesRedis);
+        this.requiresEgressProxy = this.egressProxy !== undefined;
+        this.mountLocalNodeApps = clusterConfig.mountLocalNodeApps;
+        this.serviceURLEnvVars = [
+            this.javaApps.map((javaService) => envVarForJavaService(javaService)),
+            this.nodeApps.map((nodeService) => envVarForNodeService(nodeService))
+        ].flat();
+        this.noProxyEnvVar = [
+            'localhost',
+            '127.0.0.1',
+            '172.18.0.253',
+            'localstack',
+            'redis',
+            this.payServices.map((service) => service.name),
+            this.dbServices.map((service) => service.name),
+            this.reverseProxyServices.map((service) => service.name),
+            this.egressProxy === undefined ? [] : this.egressProxy.name
+        ].flat().join(',');
+        this.environmentOverridesPath = clusterConfig.environmentOverridesPath;
+        this.defaultServiceConfigsPath = clusterConfig.defaultServiceConfigsPath;
+    }
+}
+exports.PayLocalCluster = PayLocalCluster;
+function envVarForJavaService(service) {
+    return {
+        name: `${service.name.toUpperCase()}_URL`,
+        value: `http://${service.name}:${service.port}`
+    };
+}
+function envVarForNodeService(service) {
+    return {
+        name: `${service.name.toUpperCase()}_URL`,
+        value: `http://localhost:${service.port}`
+    };
+}
+var PayServiceType;
+(function (PayServiceType) {
+    PayServiceType["Java"] = "java";
+    PayServiceType["Node"] = "node";
+})(PayServiceType || (PayServiceType = {}));
+function loadClusterConfig(options, workspace, defaultServiceConfigsPath, environmentOverridesPath) {
+    const servicesConfigPath = node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'config', 'service_config.yaml');
+    const serviceConfigFileContents = node_fs_1.default.readFileSync(servicesConfigPath, 'utf8');
+    const servicesConfig = yaml_1.default.parse(serviceConfigFileContents);
+    const payServices = [];
+    for (const [, serviceConfig] of Object.entries(servicesConfig)) {
+        if (includeAppInCluster(options.cluster, options, serviceConfig)) {
+            payServices.push(payServiceFromPayServiceConfig(serviceConfig, options, environmentOverridesPath));
+        }
+    }
+    const dbServices = [];
+    for (const payService of payServices) {
+        if (payService.payServiceConfig.db) {
+            dbServices.push(dbServiceFromPayServiceConfig(payService.payServiceConfig));
+        }
+    }
+    const reverseProxyServices = [];
+    if (options.proxy) {
+        for (const payService of payServices) {
+            if (payService.hasProxy) {
+                reverseProxyServices.push(proxyServiceFromPayServiceConfig(payService.payServiceConfig, workspace));
+            }
+        }
+    }
+    const clusterConfig = {
+        name: options.cluster,
+        payServices,
+        dbServices,
+        reverseProxyServices,
+        workspace,
+        mountLocalNodeApps: options.mount_local_node_apps,
+        defaultServiceConfigsPath,
+        environmentOverridesPath
+    };
+    return new PayLocalCluster(clusterConfig);
+}
+exports.loadClusterConfig = loadClusterConfig;
+function includeAppInCluster(cluster, options, serviceConfig) {
+    if (cluster === 'all' || cluster === 'nuke' || serviceConfig.clusters.includes(cluster)) {
+        if (options.apps.length === 0 || options.apps.includes(serviceConfig.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function payServiceFromPayServiceConfig(config, upOptions, environmentOverridesPath) {
+    const ports = [config.port];
+    if (config.admin_port !== undefined)
+        ports.push(config.admin_port);
+    const localBuild = upOptions.local.includes(config.name);
+    const sqsQueues = [];
+    if (config.queues !== undefined) {
+        for (const [envVarName, queueName] of Object.entries(config.queues)) {
+            sqsQueues.push({ envVarName, queueName });
+        }
+    }
+    const snsTopics = [];
+    if (config.sns_topics !== undefined) {
+        for (const [envVarName, topicName] of Object.entries(config.sns_topics)) {
+            snsTopics.push({ envVarName, topicName });
+        }
+    }
+    return {
+        name: config.name,
+        containerName: config.name,
+        port: config.port,
+        adminPort: config.admin_port,
+        debugPort: config.debug_port,
+        volumes: new Map(),
+        serviceType: config.type,
+        localBuild,
+        usesRedis: config.uses_redis === undefined ? false : config.uses_redis,
+        sqsQueues,
+        hasSQSQueues: sqsQueues.length > 0,
+        snsTopics,
+        hasSNSTopics: snsTopics.length > 0,
+        hasProxy: config.proxy === undefined ? false : config.proxy,
+        hasDB: config.db,
+        useEgressProxy: config.can_use_egress_proxy === undefined ? false : config.can_use_egress_proxy && upOptions.with_egress_proxy,
+        dependsOn: config.db ? [`${config.name}_db`] : [],
+        expose: [],
+        payServiceConfig: config,
+        imageTag: localBuild ? 'local' : 'latest-master',
+        requiresLocalStack: sqsQueues.length > 0 || snsTopics.length > 0,
+        entrypointOverrideLocal: config.entrypoint_override_local,
+        environmentOverrideFilePath: node_path_1.default.join(environmentOverridesPath, `${config.name}.env`)
+    };
+}
+function dbServiceFromPayServiceConfig(config) {
+    if (config.db_port === undefined) {
+        throw new Error(`The db specification for ${config.name} (which sets db: true) is missing the db_port specification`);
+    }
+    return {
+        name: `${config.name}_db`,
+        containerName: `${config.name}_db`,
+        dependsOn: [],
+        port: config.db_port,
+        expose: [],
+        volumes: new Map()
+    };
+}
+function proxyServiceFromPayServiceConfig(config, workspace) {
+    if (config.proxy_port === undefined) {
+        throw new Error(`The proxy specification for ${config.name} (which sets proxy: true) is missing the proxy_port specification`);
+    }
+    // TODO: Deal with naxsi rules file and md5s
+    const naxsiSourcePath = naxsiConfigPathForPayServiceConfig(config, workspace);
+    return {
+        name: `${config.name}-proxy`,
+        containerName: `${config.name}-proxy`,
+        appName: config.name,
+        appPort: config.port,
+        port: config.proxy_port,
+        dependsOn: [],
+        expose: [],
+        volumes: new Map(),
+        naxsiRulesSourceFile: naxsiSourcePath,
+        naxsiRulesSourceFileMD5: (0, md5_js_1.md5File)(naxsiSourcePath)
+    };
+}
+function naxsiConfigPathForPayServiceConfig(service, workspace) {
+    const naxsiSourcePath = node_path_1.default.join(workspace, 'pay-infra', 'provisioning', 'terraform', 'modules', 'pay_microservices_v2', service.name, 'files', `${service.name}.naxsi`);
+    const nasxiSourcePathStat = node_fs_1.default.statSync(naxsiSourcePath, { throwIfNoEntry: false });
+    if (nasxiSourcePathStat === undefined) {
+        throw new Error(`Reverse proxies were requested, but the naxsi config file for '${service.name}' (${naxsiSourcePath}') was not found. Perhaps you need to checkout pay-infra into your workspace directory '${workspace}'?`);
+    }
+    if (!nasxiSourcePathStat.isFile()) {
+        throw new Error(`Reverse proxies were requested, but the naxsi config file for '${service.name}' (${naxsiSourcePath}') is not a regular file. Perhaps you need to checkout pay-infra into your workspace directory '${workspace}'?`);
+    }
+    return naxsiSourcePath;
+}

package/src/commands/local/config/renderer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDockerCompose = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const handlebars_1 = __importDefault(require("handlebars"));
+/**
+ * Renders the 'if' path if both a and b are true, otherwise renders the 'else' path
+ */
+handlebars_1.default.registerHelper('ifBoth', (a, b, options) => {
+    if (a && b) {
+        return options.fn(this);
+    }
+    else {
+        return options.inverse(this);
+    }
+});
+/**
+ * Renders the 'if' path if the file specified exists, otherwise renders the 'else' path
+ */
+handlebars_1.default.registerHelper('ifFileExists', (filePath, options) => {
+    if (node_fs_1.default.existsSync(filePath)) {
+        return options.fn(this);
+    }
+    else {
+        return options.inverse(this);
+    }
+});
+/**
+ * Renders the handlebars template, writes it into the destination directory and returns the path
+ * to the file
+ */
+function renderDockerCompose(cluster, destinationDirectory) {
+    const tempalteSource = loadTemplate();
+    const template = handlebars_1.default.compile(tempalteSource);
+    const destinationFilePath = `${node_fs_1.default.realpathSync(destinationDirectory)}/${cluster.name}.yaml`;
+    node_fs_1.default.writeFileSync(destinationFilePath, template(cluster), { mode: 0o660 });
+    return destinationFilePath;
+}
+exports.renderDockerCompose = renderDockerCompose;
+function loadTemplate() {
+    return node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'templates', 'docker-compose.hbs'), 'utf8');
+}

package/src/commands/local/docker_compose_controller.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const dockerComposeController = {
+    up(composeFilePath) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'up', '--detach', '--wait'], { shell: true, stdio: 'inherit' });
+    },
+    down(composeFilePath) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'down'], { shell: true, stdio: 'inherit' });
+    },
+    nuke(composeFilePath) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'down', '--volumes'], { shell: true, stdio: 'inherit' });
+    },
+    pull(composeFilePath) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'pull'], { shell: true, stdio: 'inherit' });
+    },
+    restart(composeFilePath, service) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'restart', service], { shell: true, stdio: 'inherit' });
+    },
+    build(composeFilePath) {
+        (0, node_child_process_1.spawnSync)('docker', ['compose', '--file', composeFilePath, 'build'], { shell: true, stdio: 'inherit' });
+    }
+};
+exports.default = dockerComposeController;

package/src/commands/local/subcommands/down.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeFileToDown = exports.ENVIRONMENT_OVERRIDES_PATH = exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const configs_js_1 = require("../../../util/configs.js");
+const last_up_record_js_1 = require("../config/last_up_record.js");
+const docker_compose_controller_js_1 = __importDefault(require("../docker_compose_controller.js"));
+exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = node_path_1.default.join('local', 'docker-compose', 'rendered-templates');
+exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = node_path_1.default.join('local', 'docker-compose', 'default-configs-DO-NOT-EDIT');
+exports.ENVIRONMENT_OVERRIDES_PATH = node_path_1.default.join('local', 'environment-overrides');
+async function DownHandler(options) {
+    const renderedTempaltesPath = (0, configs_js_1.ensureConfigDirectory)(exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH);
+    const args = parseArguments(options);
+    const composeFilePath = composeFileToDown(args, renderedTempaltesPath);
+    const composeFileName = node_path_1.default.basename(composeFilePath);
+    const clusterToDown = composeFileName.substring(0, composeFileName.lastIndexOf('.yaml'));
+    console.log(`Bringing down cluster ${clusterToDown}`);
+    docker_compose_controller_js_1.default.down(composeFilePath);
+}
+exports.default = DownHandler;
+function composeFileToDown(downOptions, renderedTemplatesPath) {
+    if (downOptions.cluster !== undefined) {
+        const clusterFilePath = node_path_1.default.resolve(renderedTemplatesPath, `${downOptions.cluster}.yaml`);
+        if (node_fs_1.default.existsSync(clusterFilePath)) {
+            return clusterFilePath;
+        }
+        throw new Error(`Cannot bring down cluster '${downOptions.cluster}' since it does not have a rendered docker-compose template in ${renderedTemplatesPath}.\n` +
+            '\n' +
+            `Perhaps you don't have a cluster running, or the cluster that is running isn't ${downOptions.cluster}\n`);
+    }
+    const mostRecentUpFile = (0, last_up_record_js_1.getLastUp)(renderedTemplatesPath);
+    if (mostRecentUpFile !== undefined) {
+        return mostRecentUpFile;
+    }
+    const defaultDownFile = node_path_1.default.join(renderedTemplatesPath, 'all.yaml');
+    if (node_fs_1.default.existsSync(defaultDownFile)) {
+        return defaultDownFile;
+    }
+    throw new Error('Could not determine which cluster to bring down.\n' +
+        '\n' +
+        '  * You did not specify a cluster with --cluster.\n' +
+        "  * There is no valid record of a most recent 'up'\n" +
+        "  * The 'all' cluster rendered docker-compose.yaml file does not exist.\n" +
+        '\n' +
+        'Perhaps you do not have a running cluster, or you need to `pay local down --cluster <cluster>` specifying the last cluster you launched\n');
+}
+exports.composeFileToDown = composeFileToDown;
+function parseArguments(_options) {
+    return {
+        cluster: 'card'
+    };
+}

package/src/commands/local/subcommands/nuke.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENVIRONMENT_OVERRIDES_PATH = exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = void 0;
+const up_js_1 = __importDefault(require("./up.js"));
+const node_path_1 = __importDefault(require("node:path"));
+const docker_compose_controller_js_1 = __importDefault(require("../docker_compose_controller.js"));
+exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = node_path_1.default.join('local', 'docker-compose', 'rendered-templates');
+exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = node_path_1.default.join('local', 'docker-compose', 'default-configs-DO-NOT-EDIT');
+exports.ENVIRONMENT_OVERRIDES_PATH = node_path_1.default.join('local', 'environment-overrides');
+async function NukeHandler() {
+    const upOptions = {
+        cluster: 'nuke',
+        proxy: true,
+        with_egress_proxy: true,
+        apps: [],
+        local: [],
+        rebuild: false,
+        pull: false,
+        mount_local_node_apps: false
+    };
+    const renderedTemplatePath = await (0, up_js_1.default)(upOptions, true);
+    console.log('Nuking cluster');
+    docker_compose_controller_js_1.default.nuke(renderedTemplatePath);
+}
+exports.default = NukeHandler;

package/src/commands/local/subcommands/otp.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const totp_generator_1 = require("totp-generator");
+async function OTPHandler(options) {
+    const args = parseArguments(options);
+    const { otp } = totp_generator_1.TOTP.generate(args.secret);
+    console.log(otp);
+    copyToClipboard(otp);
+    console.log(`📋 “${otp}” copied to clipboard`);
+}
+exports.default = OTPHandler;
+function parseArguments(options) {
+    if (options.length !== 1) {
+        help();
+        throw new Error('No key specified');
+    }
+    return { secret: options[0].trimEnd() };
+}
+function copyToClipboard(otp) {
+    const proc = (0, node_child_process_1.spawn)('pbcopy');
+    proc.stdin.write(otp);
+    proc.stdin.end();
+}
+function help() {
+    console.log('Usage: pay local otp <otp_secret_key>');
+}

package/src/commands/local/subcommands/restart.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const configs_js_1 = require("../../../util/configs.js");
+const last_up_record_js_1 = require("../config/last_up_record.js");
+const docker_compose_controller_js_1 = __importDefault(require("../docker_compose_controller.js"));
+exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = node_path_1.default.join('local', 'docker-compose', 'rendered-templates');
+async function DownHandler(options) {
+    const renderedTempaltesPath = (0, configs_js_1.ensureConfigDirectory)(exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH);
+    const args = parseArguments(options);
+    const composeFilePath = (0, last_up_record_js_1.getLastUp)(renderedTempaltesPath);
+    if (composeFilePath === undefined) {
+        throw new Error('Cannot find the docker-compose file for the running cluster');
+    }
+    const composeFileName = node_path_1.default.basename(composeFilePath);
+    const clusterName = composeFileName.substring(0, composeFileName.lastIndexOf('.yaml'));
+    console.log(`\nRestarting '${args.service} in cluster ${clusterName}`);
+    docker_compose_controller_js_1.default.restart(composeFilePath, args.service);
+}
+exports.default = DownHandler;
+function parseArguments(options) {
+    if (options.length !== 1) {
+        throw new Error('Incorrect number of arguments, expected 1 to restart command\n' +
+            '\n' +
+            '  Usage: pay local restart <service>\n' +
+            '\n');
+    }
+    return {
+        service: options[0]
+    };
+}

package/src/commands/local/subcommands/up.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENVIRONMENT_OVERRIDES_PATH = exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = void 0;
+const path_1 = __importDefault(require("path"));
+const docker_compose_controller_js_1 = __importDefault(require("../docker_compose_controller.js"));
+const configs_js_1 = require("../../../util/configs.js");
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+const renderer_js_1 = require("../config/renderer.js");
+const last_up_record_js_1 = require("../config/last_up_record.js");
+const default_config_setup_js_1 = require("../config/default_config_setup.js");
+exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH = path_1.default.join('local', 'docker-compose', 'rendered-templates');
+exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH = path_1.default.join('local', 'docker-compose', 'default-configs-DO-NOT-EDIT');
+exports.ENVIRONMENT_OVERRIDES_PATH = path_1.default.join('local', 'environment-overrides');
+async function UpHandler(options, onlyWriteConfig = false) {
+    const workspace = (0, configs_js_1.workspaceEnvVar)();
+    const renderedTemplatesPath = (0, configs_js_1.ensureConfigDirectory)(exports.DOCKER_COMPOSE_RENDERED_TEMPALTES_PATH);
+    const composeServicesConfigPath = (0, configs_js_1.ensureConfigDirectory)(exports.DOCKER_COMPOSE_SERVICES_CONFIG_PATH);
+    const environmentOverridesPath = (0, configs_js_1.ensureConfigDirectory)(exports.ENVIRONMENT_OVERRIDES_PATH);
+    (0, default_config_setup_js_1.copyDefaultConfigs)(composeServicesConfigPath);
+    const args = options instanceof Array ? parseArguments(options) : options;
+    const clusterConfig = (0, pay_local_cluster_js_1.loadClusterConfig)(args, workspace, composeServicesConfigPath, environmentOverridesPath);
+    const renderedTemplatePath = (0, renderer_js_1.renderDockerCompose)(clusterConfig, renderedTemplatesPath);
+    console.log(`docker-compose yaml written to ${renderedTemplatePath}`);
+    (0, last_up_record_js_1.recordUp)(renderedTemplatesPath, clusterConfig);
+    if (onlyWriteConfig) {
+        return renderedTemplatePath;
+    }
+    if (args.pull) {
+        console.log(`\nPulling containers for cluster ${clusterConfig.name}`);
+        docker_compose_controller_js_1.default.pull(renderedTemplatePath);
+    }
+    if (args.local.length > 0 && args.rebuild) {
+        console.log(`\nBuilding all local apps for cluster ${clusterConfig.name}`);
+        docker_compose_controller_js_1.default.build(renderedTemplatePath);
+    }
+    console.log(`\nGoing up with cluster ${clusterConfig.name}`);
+    docker_compose_controller_js_1.default.up(renderedTemplatePath);
+    return renderedTemplatePath;
+}
+exports.default = UpHandler;
+function parseArguments(_options) {
+    return {
+        cluster: 'card',
+        apps: [],
+        local: ['cardid', 'frontend'],
+        proxy: true,
+        with_egress_proxy: false,
+        rebuild: true,
+        pull: true,
+        mount_local_node_apps: false
+    };
+}

package/src/commands/local.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const standardContent_js_1 = require("../core/standardContent.js");
+const legacy_1 = __importDefault(require("../commands/legacy"));
+const otp_js_1 = __importDefault(require("./local/subcommands/otp.js"));
+const up_js_1 = __importDefault(require("./local/subcommands/up.js"));
+const down_js_1 = __importDefault(require("./local/subcommands/down.js"));
+const nuke_js_1 = __importDefault(require("./local/subcommands/nuke.js"));
+const restart_js_1 = __importDefault(require("./local/subcommands/restart.js"));
+const SUBCOMMANDS_NOT_YET_IMPLEMENTED = [
+    'account',
+    'browse',
+    'db',
+    'payment',
+    'paymentlink',
+    'token',
+    'url',
+    'user'
+];
+var LocalCommand;
+(function (LocalCommand) {
+    LocalCommand["OTP"] = "otp";
+    LocalCommand["Up"] = "up";
+    LocalCommand["Launch"] = "launch";
+    LocalCommand["Down"] = "down";
+    LocalCommand["Restart"] = "restart";
+    LocalCommand["Nuke"] = "nuke";
+    LocalCommand["Help"] = "help";
+    LocalCommand["Unknown"] = "Unknown";
+})(LocalCommand || (LocalCommand = {}));
+async function localHandler(options) {
+    // Not everything is implemented yet. Lets hand off to the legacy handler for unimplemented
+    // subcommands
+    if (options.arguments.length > 0 && SUBCOMMANDS_NOT_YET_IMPLEMENTED.includes(options.arguments[0])) {
+        options.commandName = 'local';
+        await (0, legacy_1.default)(options);
+        return;
+    }
+    await (0, standardContent_js_1.showHeader)();
+    const { subcommand, subcommandOptions } = parseArguments(options);
+    switch (subcommand) {
+        case LocalCommand.OTP: {
+            await (0, otp_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Up: {
+            await (0, up_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Launch: {
+            await (0, up_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Down: {
+            await (0, down_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Restart: {
+            await (0, restart_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Nuke: {
+            await (0, nuke_js_1.default)();
+            break;
+        }
+        case LocalCommand.Help:
+        case LocalCommand.Unknown: {
+            help();
+            break;
+        }
+        default: {
+            help();
+            break;
+        }
+    }
+}
+exports.default = localHandler;
+// TODO: Replace this with yargs
+function parseArguments(options) {
+    const subcommandOptions = options.arguments;
+    const subcommand = subcommandOptions.shift();
+    switch (subcommand) {
+        case LocalCommand.OTP: return { subcommand, subcommandOptions };
+        case LocalCommand.Up: return { subcommand, subcommandOptions };
+        case LocalCommand.Launch: return { subcommand, subcommandOptions };
+        case LocalCommand.Down: return { subcommand, subcommandOptions };
+        case LocalCommand.Restart: return { subcommand, subcommandOptions };
+        case LocalCommand.Nuke: return { subcommand, subcommandOptions };
+        case LocalCommand.Help: return { subcommand, subcommandOptions };
+        default: return { subcommand: LocalCommand.Unknown, subcommandOptions };
+    }
+}
+function help() {
+    console.error('USAGE FOLLOWS');
+}

package/src/core/commandRouter.js

@@ -7,6 +7,7 @@ const standardContent_js_1 = require("./standardContent.js");
 const browse_js_1 = __importDefault(require("../commands/browse.js"));
 const demo_js_1 = __importDefault(require("../commands/demo.js"));
 const legacy_1 = __importDefault(require("../commands/legacy"));
+const local_js_1 = __importDefault(require("../commands/local.js"));
 const help_1 = __importDefault(require("../commands/help"));
 const tunnel_js_1 = __importDefault(require("../commands/tunnel.js"));
 const package_json_1 = __importDefault(require("../../package.json"));
@@ -30,6 +31,9 @@ handlers.set('help', {
 handlers.set('local', {
     handler: legacy_1.default
 });
+handlers.set('localx', {
+    handler: local_js_1.default
+});
 handlers.set('schema', {
     handler: legacy_1.default
 });

package/src/util/configs.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceEnvVar = exports.ensureConfigDirectory = exports.PAY_CLI_CONFIG_PATH = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+exports.PAY_CLI_CONFIG_PATH = node_path_1.default.join((0, node_os_1.homedir)(), '.pay-cli');
+/**
+ * This function validates a config path within the pay cli config dir exists, if it does then it creates it.
+ * It does this by joining all the subPath param elements onto the end of the default config path
+ * using path.join.
+ *
+ * Returns the absolute file path
+ */
+function ensureConfigDirectory(...subPath) {
+    const fullConfigDirPath = node_path_1.default.resolve(node_path_1.default.join(exports.PAY_CLI_CONFIG_PATH, ...subPath));
+    const configPathStat = node_fs_1.default.statSync(fullConfigDirPath, { throwIfNoEntry: false });
+    if (configPathStat === undefined) {
+        node_fs_1.default.mkdirSync(fullConfigDirPath, { mode: 0o770, recursive: true });
+    }
+    else if (!configPathStat.isDirectory()) {
+        throw new Error(`pay local config path ${fullConfigDirPath} already exists and is not a directory, cannot continue`);
+    }
+    return fullConfigDirPath;
+}
+exports.ensureConfigDirectory = ensureConfigDirectory;
+/**
+ * This function validates the the WORKSPACE env var is set, and that it is directory that exists.
+ */
+function workspaceEnvVar() {
+    const workspacePath = process.env.WORKSPACE;
+    if (workspacePath === undefined) {
+        throw new Error('Error, the WORKSPACE env var must be set to the parent directory of where you check out your pay repositories');
+    }
+    const workspacePathStat = node_fs_1.default.statSync(workspacePath, { throwIfNoEntry: false });
+    if (workspacePathStat === undefined) {
+        throw new Error(`Error, the WORKSPACE env var is set to '${workspacePath}' which doesn't exist. This must be set to the parent directory of where you check out your pay repositories`);
+    }
+    if (!workspacePathStat.isDirectory()) {
+        throw new Error(`Error, the WORKSPACE env var is set to '${workspacePath}' which exists, but is not a directory. This must be set to the parent directory of where you check out your pay repositories`);
+    }
+    return workspacePath;
+}
+exports.workspaceEnvVar = workspaceEnvVar;