@govuk-pay/cli 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@govuk-pay/cli",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "GOV.UK Pay Command Line Interface",
   "bin": {
     "pay": "bin/cli.js",
@@ -22,7 +22,6 @@
     "openurl": "^1.1.1",
     "semver": "^7.6.3",
     "totp-generator": "^1.0.0",
-    "ts-standard": "^12.0.2",
     "yaml": "^2.5.1"
   },
   "files": [

package/resources/pay-local/templates/docker-compose.hbs

@@ -178,7 +178,7 @@ services:
     {{#ifBoth localBuild entrypointOverrideLocal}}
     entrypoint: {{{../entrypointOverrideLocal}}}
     {{else}}
-    entrypoint: "npx nodemon --inspect=0.0.0.0:{{../debugPort}} start.js"
+    entrypoint: "npx nodemon --inspect=0.0.0.0:{{../debugPort}}"
     {{/ifBoth}}
     ports:
       - "{{port}}:{{port}}"

package/src/commands/local/app_client/app_client.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const fetch_wrapper_1 = require("./fetch_wrapper");
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+let SERVICES_CONFIG;
+const appClient = {
+    async createPaymentLink(apiKey) {
+        const paymentLinkData = {
+            pay_api_token: apiKey,
+            name: 'exampleName',
+            price: 100,
+            gateway_account_id: '1',
+            return_url: 'https://test.test/some_reference',
+            service_name: 'aServiceName',
+            type: 'ADHOC',
+            service_name_path: 'aServiceNamePath',
+            product_name_path: node_crypto_1.default.randomBytes(16).toString('hex'),
+            reference_enabled: false
+        };
+        const url = urlFor('products', '/v1/api/products/');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, paymentLinkData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a request payment links did not have a body, or the body was not JSON!');
+            return;
+        }
+        if (!Object.hasOwn(body, '_links')) {
+            console.error('The response to create a payment link did not include an _links property');
+            return;
+        }
+        const typedBody = body;
+        return typedBody._links;
+    },
+    async createService() {
+        const createServiceData = {
+            en: 'My service',
+            cy: 'Welsh name for My service'
+        };
+        const url = urlFor('adminusers', '/v1/api/services');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createServiceData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a service did not have a body, or the body was not JSON!');
+            return;
+        }
+        if (!Object.hasOwn(body, 'external_id')) {
+            console.error('The response to create a service did not include an external_id property');
+            return;
+        }
+        const typedBody = body;
+        return typedBody.external_id;
+    },
+    async createAccountInServiceWithEmailCollectionMode(serviceExternalID, emailCollectionMode) {
+        const account = await appClient.createAccount(serviceExternalID);
+        if (account === undefined) {
+            console.error('Failed to create account');
+            return;
+        }
+        if (!await appClient.setEmailCollectionModeOnAccount(account.gateway_account_id, emailCollectionMode)) {
+            console.error('Failed to set email collection mode on gateway account');
+            return;
+        }
+        if (!await appClient.addGatewayAccountToService(account.gateway_account_id, serviceExternalID)) {
+            console.error('Failed to add the gateway account to the service');
+            return;
+        }
+        return account;
+    },
+    async createAccount(serviceID) {
+        const createAccountData = {
+            payment_provider: 'sandbox',
+            service_name: 'My service',
+            type: 'test',
+            service_id: serviceID
+        };
+        const url = urlFor('connector', '/v1/api/accounts');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createAccountData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create an account did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedBody = body;
+        return typedBody;
+    },
+    async setEmailCollectionModeOnAccount(accountID, emailCollectionMode) {
+        const patchEmailCollectionModeData = {
+            op: 'replace',
+            path: 'email_collection_mode',
+            value: emailCollectionMode
+        };
+        const url = urlFor('connector', `/v1/api/accounts/${accountID}`);
+        const result = await (0, fetch_wrapper_1.patchRequest)(url, patchEmailCollectionModeData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return false;
+        }
+        return true;
+    },
+    async addGatewayAccountToService(accountID, serviceID) {
+        const patchAddGatewayAccountToServiceData = {
+            op: 'add',
+            path: 'gateway_account_ids',
+            value: [accountID]
+        };
+        const url = urlFor('adminusers', `/v1/api/services/${serviceID}`);
+        const result = await (0, fetch_wrapper_1.patchRequest)(url, patchAddGatewayAccountToServiceData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return false;
+        }
+        return true;
+    },
+    async createToken(gatewayAccountID) {
+        const createTokenData = {
+            account_id: gatewayAccountID,
+            description: 'my token',
+            created_by: 'system generated',
+            token_type: 'CARD'
+        };
+        const url = urlFor('publicauth', '/v1/frontend/auth');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createTokenData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a token did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedBody = body;
+        return typedBody.token;
+    },
+    async createPayment(apiToken) {
+        const createPaymentData = {
+            amount: 1000,
+            description: 'my payment',
+            reference: 'my payment reference',
+            return_url: new URL('https://www.payments.service.gov.uk')
+        };
+        const url = urlFor('publicapi', '/v1/payments');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createPaymentData, apiToken);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a payment did not have a body, or the body was not JSON!');
+            return;
+        }
+        return body;
+    },
+    async createUser(gatewayAccountIDs, roleName) {
+        const createUserData = {
+            gateway_account_ids: gatewayAccountIDs,
+            email: `${node_crypto_1.default.randomBytes(16).toString('hex')}@example.com`,
+            password: `${node_crypto_1.default.randomBytes(10).toString('hex')}`,
+            telephone_number: '01134960000',
+            role_name: roleName
+        };
+        const url = urlFor('adminusers', '/v1/api/users');
+        const result = await (0, fetch_wrapper_1.postRequest)(url, createUserData);
+        if (!result.success) {
+            console.error((0, fetch_wrapper_1.formatErrorMessageForFailedRequest)(result.unsuccessfulResult));
+            return;
+        }
+        const body = result.successfulResult?.body;
+        if (body === undefined || typeof body === 'string') {
+            console.error('The response to a create a user did not have a body, or the body was not JSON!');
+            return;
+        }
+        const typedAugmentedBody = {
+            ...createUserData,
+            ...body
+        };
+        return typedAugmentedBody;
+    },
+    async isHealthy(serviceName) {
+        const url = urlFor(serviceName, '/healthcheck');
+        const response = await (0, fetch_wrapper_1.getRequest)(url);
+        return response.success;
+    },
+    async isUnhealthy(serviceName) {
+        return !await this.isHealthy(serviceName);
+    },
+    async isProxyHealthy(serviceName) {
+        const proxyUrl = this.externalUrlFor(serviceName, '/healthcheck', true);
+        const response = await (0, fetch_wrapper_1.getRequest)(proxyUrl);
+        return response.success;
+    },
+    externalUrlFor(serviceName, resource, proxy) {
+        if (SERVICES_CONFIG === undefined) {
+            SERVICES_CONFIG = (0, pay_local_cluster_js_1.loadServicesConfig)();
+        }
+        if (!(serviceName in SERVICES_CONFIG)) {
+            throw new Error(`Tried to look up service config for ${serviceName} but it isn't defined in the service_config.yaml file`);
+        }
+        const proxyPort = SERVICES_CONFIG[serviceName].proxy_port;
+        if (proxy && proxyPort !== undefined) {
+            return `https://127.0.0.1:${proxyPort}${resource}`;
+        }
+        return `http://127.0.0.1:${SERVICES_CONFIG[serviceName].port}${resource}`;
+    }
+};
+function urlFor(serviceName, resource) {
+    if (SERVICES_CONFIG === undefined) {
+        SERVICES_CONFIG = (0, pay_local_cluster_js_1.loadServicesConfig)();
+    }
+    if (!(serviceName in SERVICES_CONFIG)) {
+        throw new Error(`Tried to look up service config for ${serviceName} but it isn't defined in the service_config.yaml file`);
+    }
+    return appClient.externalUrlFor(serviceName, resource, false);
+}
+exports.default = appClient;

package/src/commands/local/app_client/fetch_wrapper.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorMessageForFailedRequest = exports.patchRequest = exports.postRequest = exports.getRequest = void 0;
+async function getRequest(url, authToken) {
+    return await makeRequest(url, { headers: defaultHeaders(authToken) });
+}
+exports.getRequest = getRequest;
+async function postRequest(url, body, authToken) {
+    return await makeRequest(url, {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers: defaultHeaders(authToken)
+    });
+}
+exports.postRequest = postRequest;
+async function patchRequest(url, body, authToken) {
+    return await makeRequest(url, {
+        method: 'PATCH',
+        body: JSON.stringify(body),
+        headers: defaultHeaders(authToken)
+    });
+}
+exports.patchRequest = patchRequest;
+function formatErrorMessageForFailedRequest(unsuccessfulResult) {
+    if (unsuccessfulResult === undefined) {
+        return 'The result was successful';
+    }
+    let errorMessage = '';
+    if (unsuccessfulResult.error !== null && unsuccessfulResult.error !== undefined) {
+        errorMessage = unsuccessfulResult.error.message;
+    }
+    if (unsuccessfulResult.response === undefined) {
+        return `No response was received from the server, the following error was thrown:\n${errorMessage}`;
+    }
+    else {
+        if (unsuccessfulResult.error === undefined) {
+            return 'The server returned a non-ok HTTP response, no other error was thrown\n' +
+                `Response Code: ${unsuccessfulResult.response?.status}\n` +
+                `Response Text: ${unsuccessfulResult.response?.statusText}`;
+        }
+        else {
+            return 'A response was recevied from the server, but an error was also thrown.\n' +
+                `Error: ${errorMessage}` +
+                `Response Code: ${unsuccessfulResult?.response?.status}\n` +
+                `Response Text: ${unsuccessfulResult?.response?.statusText}`;
+        }
+    }
+}
+exports.formatErrorMessageForFailedRequest = formatErrorMessageForFailedRequest;
+/**
+ * The error handling around requests is absymal, so we'll catch all possible errors and return a result with a
+ * concrete type which is easier for clients to understand and deal with, containing the complexity to only this
+ * function
+ */
+async function makeRequest(url, requestOptions) {
+    let response;
+    try {
+        response = await fetch(url, requestOptions);
+        if (!response.ok) {
+            return {
+                success: false,
+                unsuccessfulResult: {
+                    response
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            unsuccessfulResult: {
+                error
+            }
+        };
+    }
+    try {
+        const rawBody = await response.text();
+        const jsonResponse = response.headers.get('Content-Type') === 'application/json';
+        return {
+            success: true,
+            successfulResult: {
+                response,
+                body: jsonResponse ? await JSON.parse(rawBody) : rawBody
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            unsuccessfulResult: {
+                response,
+                error
+            }
+        };
+    }
+}
+function defaultHeaders(authToken) {
+    const headers = new Headers({
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+    });
+    if (authToken !== undefined) {
+        headers.set('Authorization', `Bearer ${authToken}`);
+    }
+    return headers;
+}

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

@@ -3,7 +3,7 @@ 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;
+exports.loadServicesConfig = 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"));
@@ -89,9 +89,7 @@ var PayServiceType;
     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 servicesConfig = loadServicesConfig();
     const payServices = [];
     for (const [, serviceConfig] of Object.entries(servicesConfig)) {
         if (includeAppInCluster(options.cluster, options, serviceConfig)) {
@@ -125,6 +123,12 @@ function loadClusterConfig(options, workspace, defaultServiceConfigsPath, enviro
     return new PayLocalCluster(clusterConfig);
 }
 exports.loadClusterConfig = loadClusterConfig;
+function loadServicesConfig() {
+    const servicesConfigPath = node_path_1.default.join(__dirname, '..', '..', '..', '..', 'resources', 'pay-local', 'config', 'service_config.yaml');
+    const serviceConfigFileContents = node_fs_1.default.readFileSync(servicesConfigPath, 'utf8');
+    return yaml_1.default.parse(serviceConfigFileContents);
+}
+exports.loadServicesConfig = loadServicesConfig;
 function includeAppInCluster(cluster, options, serviceConfig) {
     if (cluster === 'all' || cluster === 'nuke' || serviceConfig.clusters.includes(cluster)) {
         if (options.apps.length === 0 || options.apps.includes(serviceConfig.name)) {

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+async function AccountHandler(options) {
+    const args = parseArguments(options);
+    if (await app_client_js_1.default.isUnhealthy('adminusers')) {
+        console.error('The adminusers service is unhealthy, so an account cannot be created');
+        return;
+    }
+    if (await app_client_js_1.default.isUnhealthy('connector')) {
+        console.error('The connector service is unhealthy, so an account cannot be created');
+        return;
+    }
+    let serviceExternalID;
+    if (args.serviceID === undefined) {
+        serviceExternalID = await app_client_js_1.default.createService();
+        if (serviceExternalID === undefined) {
+            console.error('Service creation failed');
+            return;
+        }
+    }
+    else {
+        serviceExternalID = args.serviceID;
+    }
+    if (serviceExternalID === undefined) {
+        throw new Error('Service external ID is undefined, this should be impossible');
+    }
+    const account = await app_client_js_1.default.createAccountInServiceWithEmailCollectionMode(serviceExternalID, 'MANDATORY');
+    if (account === undefined) {
+        console.error('Failed to create a fully set up account');
+        return;
+    }
+    console.log(account);
+}
+exports.default = AccountHandler;
+function parseArguments(options) {
+    if (options.length === 0) {
+        return {};
+    }
+    if (options.length > 1) {
+        help();
+        throw new Error('Too many arguments');
+    }
+    return { serviceID: options[0] };
+}
+function help() {
+    console.log('Usage: pay local account [service_id]>');
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+async function BrowseHandler(options) {
+    const args = parseArguments(options);
+    const servicesConfig = (0, pay_local_cluster_js_1.loadServicesConfig)();
+    if (!(args.service in servicesConfig)) {
+        console.error(`The service specified (${args.service}) was not defined in the service_config.yaml file`);
+        return;
+    }
+    const serviceConfig = servicesConfig[args.service];
+    const url = app_client_js_1.default.externalUrlFor(args.service, '/', args.proxy);
+    (0, node_child_process_1.spawn)('open', [url]);
+    if (await app_client_js_1.default.isHealthy(serviceConfig.name)) {
+        console.log(`📋 “${url}” opened`);
+    }
+    else {
+        console.error(`❌ “${url}” opened, however the app did not respond successfully to ${url}/healthcheck`);
+    }
+}
+exports.default = BrowseHandler;
+function help() {
+    console.log('Usage: pay local browse <service>');
+}
+function parseArguments(options) {
+    if (options.length !== 1) {
+        help();
+        throw new Error('No service specified');
+    }
+    return {
+        service: options[0],
+        proxy: true
+    };
+}

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+async function DBHandler(options) {
+    const args = parseArguments(options);
+    const servicesConfig = (0, pay_local_cluster_js_1.loadServicesConfig)();
+    if (!(args.service in servicesConfig)) {
+        console.error(`The service specified (${args.service}) was not defined in the service_config.yaml file`);
+        return;
+    }
+    const serviceConfig = servicesConfig[args.service];
+    if (!serviceConfig.db) {
+        console.error(`The service specified (${serviceConfig.name}) does not have a database`);
+        return;
+    }
+    if (args.docker) {
+        launchPsqlInDocker(serviceConfig);
+    }
+    else if (!psqlAvailable()) {
+        console.warn('PSQL installation not found locally.');
+        launchPsqlInDocker(serviceConfig);
+    }
+    else {
+        launchPsql(serviceConfig);
+    }
+}
+exports.default = DBHandler;
+function psqlAvailable() {
+    const psqlCheck = (0, node_child_process_1.spawnSync)('command', ['-v', 'psql'], { shell: true });
+    if (psqlCheck.status === 0) {
+        return true;
+    }
+    return false;
+}
+function launchPsqlInDocker(serviceConfig) {
+    console.log('Running psql in running app db container.');
+    console.log('Note: This means you wont have a psql history, and one will not survive restarts of pay local');
+    (0, node_child_process_1.spawn)('docker', [
+        'exec',
+        '-e', 'PGPASSWORD=mysecretpassword', // pragma: allowlist secret
+        '-e', 'PGSSLMODE=disable',
+        '-ti',
+        `${serviceConfig.name}_db`,
+        'psql',
+        '--host', `${serviceConfig.name}_db`,
+        '--user', serviceConfig.name,
+        '--dbname', serviceConfig.name
+    ], { stdio: 'inherit', shell: true });
+}
+function launchPsql(serviceConfig) {
+    if (serviceConfig.db_port === undefined) {
+        throw new Error(`Service config for ${serviceConfig.name} is missing db_port specification`);
+    }
+    (0, node_child_process_1.spawn)('psql', [
+        '--host', '127.0.0.1',
+        '--port', `${serviceConfig.db_port}`,
+        '--user', serviceConfig.name,
+        '--dbname', serviceConfig.name
+    ], {
+        stdio: 'inherit',
+        shell: true,
+        env: {
+            ...process.env,
+            PGPASSWORD: 'mysecretpassword', // pragma: allowlist secret
+            PGSSLMODE: 'disable'
+        }
+    });
+}
+function help() {
+    console.log('Usage: pay local db <service> [--docker]');
+}
+function parseArguments(options) {
+    if (options.length !== 1) {
+        help();
+        throw new Error('No service specified');
+    }
+    return {
+        service: options[0],
+        docker: false
+    };
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+async function PaymentHandler(options) {
+    const args = parseArguments(options);
+    if (await app_client_js_1.default.isUnhealthy('connector')) {
+        console.error('The connector service is unhealthy, so a payment cannot be created');
+        return;
+    }
+    if (await app_client_js_1.default.isUnhealthy('publicapi')) {
+        console.error('The publicapi service is unhealthy, so a payment cannot be created');
+        return;
+    }
+    let apiKey;
+    if (args.api_key === undefined) {
+        console.warn('👔  Creating gateway account and service');
+        console.warn();
+        if (await app_client_js_1.default.isUnhealthy('adminusers')) {
+            console.error('The adminusers service is unhealthy, so a gateway account cannot be created to enable a payment to be created');
+            return;
+        }
+        const serviceExternalID = await app_client_js_1.default.createService();
+        if (serviceExternalID === undefined) {
+            console.error('Unable to create a service');
+            return;
+        }
+        const account = await app_client_js_1.default.createAccountInServiceWithEmailCollectionMode(serviceExternalID, args.email_collection_mode === undefined ? 'MANDATORY' : args.email_collection_mode);
+        if (account === undefined) {
+            console.error('Failed to create a fully set up account');
+            return;
+        }
+        const createTokenResult = await app_client_js_1.default.createToken(account.gateway_account_id);
+        if (createTokenResult === undefined) {
+            console.error('Failed to create an api token');
+            return;
+        }
+        apiKey = createTokenResult;
+        console.warn(`🆔  Gateway account ID: ${account.gateway_account_id}`);
+        console.warn(`💁  Service ID: ${serviceExternalID}`);
+        console.warn();
+    }
+    else {
+        apiKey = args.api_key;
+    }
+    const createPaymentResult = await app_client_js_1.default.createPayment(apiKey);
+    if (createPaymentResult === undefined) {
+        console.error('Failed to create a payment');
+        return;
+    }
+    console.warn(`💷  Payment ID: ${createPaymentResult.payment_id}`);
+    console.warn(`🎫  API token: ${apiKey}`);
+    console.warn();
+    const nextUrl = createPaymentResult._links.next_url?.href;
+    if (nextUrl === undefined) {
+        console.error('The response from creating the payment did not include a next_url link');
+        return;
+    }
+    console.log(`Opening next_url (${nextUrl} in your browser`);
+    (0, node_child_process_1.spawn)('open', [nextUrl]);
+}
+exports.default = PaymentHandler;
+function parseArguments(_options) {
+    return {};
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = __importDefault(require("node:child_process"));
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+async function PaymentLinkHandler(options) {
+    const args = parseArguments(options);
+    if (await app_client_js_1.default.isUnhealthy('products')) {
+        console.error('The products service is unhealthy, so a payment link cannot be created');
+        return;
+    }
+    else if (await app_client_js_1.default.isUnhealthy('products-ui')) {
+        console.error('The products-ui service is unhealthy, so a payment link cannot be created');
+        return;
+    }
+    const paymentLinks = await app_client_js_1.default.createPaymentLink(args.apiKey);
+    if (paymentLinks === undefined) {
+        console.error('Payment link creation failed');
+        return;
+    }
+    paymentLinks.forEach((link) => { console.log(`${link.method} ${link.rel}: ${link.href}`); });
+    const payLink = paymentLinks.find((link) => link.rel === 'pay');
+    if (payLink === undefined) {
+        console.error('The response to create a payment link did not include a link with the rel of "pay"');
+        return;
+    }
+    node_child_process_1.default.spawn('open', [payLink.href]);
+}
+exports.default = PaymentLinkHandler;
+function parseArguments(options) {
+    if (options.length !== 1) {
+        help();
+        throw new Error('No key specified');
+    }
+    return { apiKey: options[0].trimEnd() };
+}
+function help() {
+    console.log('Usage: pay local paymentlink <api_key>');
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+async function TokenHandler(options) {
+    const args = parseArguments(options);
+    if (await app_client_js_1.default.isUnhealthy('publicauth')) {
+        console.error('The publicauth service is unhealthy, so an API token cannot be created');
+        return;
+    }
+    let gatewayAccountID;
+    if (args.gatewayAccountID === undefined) {
+        console.log('No gateway_account_id provided, creating service and gateway account');
+        if (await app_client_js_1.default.isUnhealthy('adminusers')) {
+            console.error('The adminusers service is unhealthy, so an API token cannot be created');
+            return;
+        }
+        if (await app_client_js_1.default.isUnhealthy('connector')) {
+            console.error('The connector service is unhealthy, so an API token cannot be created');
+            return;
+        }
+        const serviceExternalID = await app_client_js_1.default.createService();
+        if (serviceExternalID === undefined) {
+            console.error('Service creation failed');
+            return;
+        }
+        const account = await app_client_js_1.default.createAccountInServiceWithEmailCollectionMode(serviceExternalID, 'MANDATORY');
+        if (account === undefined) {
+            console.error('Failed to create a fully set up account');
+            return;
+        }
+        gatewayAccountID = account.gateway_account_id;
+    }
+    else {
+        gatewayAccountID = args.gatewayAccountID;
+    }
+    const token = await app_client_js_1.default.createToken(gatewayAccountID);
+    if (token === undefined) {
+        console.error('Failed to create an API token');
+        return;
+    }
+    copyToClipboard(token);
+    console.log(`📋 API token “${token}” copied to clipboard`);
+}
+exports.default = TokenHandler;
+function parseArguments(options) {
+    if (options.length === 0) {
+        return {};
+    }
+    if (options.length > 1) {
+        help();
+        throw new Error('Too many arguments');
+    }
+    return { gatewayAccountID: options[0] };
+}
+function copyToClipboard(token) {
+    const proc = (0, node_child_process_1.spawn)('pbcopy');
+    proc.stdin.write(token);
+    proc.stdin.end();
+}
+function help() {
+    console.log('Usage: pay local token [gateway_account_id]>');
+}

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

@@ -43,9 +43,9 @@ async function UpHandler(options, onlyWriteConfig = false) {
 exports.default = UpHandler;
 function parseArguments(_options) {
     return {
-        cluster: 'card',
+        cluster: 'all',
         apps: [],
-        local: ['cardid', 'frontend'],
+        local: [], // ['cardid', 'frontend'],
         proxy: true,
         with_egress_proxy: false,
         rebuild: true,

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+const pay_local_cluster_js_1 = require("../config/pay_local_cluster.js");
+async function URLHandler(options) {
+    const args = parseArguments(options);
+    const servicesConfig = (0, pay_local_cluster_js_1.loadServicesConfig)();
+    if (!(args.service in servicesConfig)) {
+        console.error(`The service specified (${args.service}) was not defined in the service_config.yaml file`);
+        return;
+    }
+    const serviceConfig = servicesConfig[args.service];
+    const url = app_client_js_1.default.externalUrlFor(args.service, '/', args.proxy);
+    copyToClipboard(url);
+    if (await app_client_js_1.default.isHealthy(serviceConfig.name)) {
+        console.log(`📋 “${url}” copied to clipboard`);
+    }
+    else {
+        console.error(`❌ “${url}” copied to clipboard, however the app did not respond successfully to ${url}/healthcheck`);
+    }
+}
+exports.default = URLHandler;
+function copyToClipboard(url) {
+    const proc = (0, node_child_process_1.spawn)('pbcopy');
+    proc.stdin.write(url);
+    proc.stdin.end();
+}
+function help() {
+    console.log('Usage: pay local url <service>');
+}
+function parseArguments(options) {
+    if (options.length !== 1) {
+        help();
+        throw new Error('No service specified');
+    }
+    return {
+        service: options[0],
+        proxy: false
+    };
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_client_js_1 = __importDefault(require("../app_client/app_client.js"));
+const totp_generator_1 = require("totp-generator");
+const node_child_process_1 = require("node:child_process");
+async function UserHandler(options) {
+    const args = parseArguments(options);
+    if (await app_client_js_1.default.isUnhealthy('adminusers')) {
+        console.error('The adminusers service is unhealthy, so a user cannot be created');
+        return;
+    }
+    if (await app_client_js_1.default.isUnhealthy('connector')) {
+        console.error('The connector service is unhealthy, so a user cannot be created');
+        return;
+    }
+    console.warn('Creating card gateway account and API token');
+    const serviceExternalID = await app_client_js_1.default.createService();
+    if (serviceExternalID === undefined) {
+        console.error('Service creation failed');
+        return;
+    }
+    const account = await app_client_js_1.default.createAccountInServiceWithEmailCollectionMode(serviceExternalID, 'MANDATORY');
+    if (account === undefined) {
+        console.error('Failed to create a fully set up account');
+        return;
+    }
+    const apiToken = await app_client_js_1.default.createToken(account.gateway_account_id);
+    if (apiToken === undefined) {
+        console.error('Failed to create an API token');
+        return;
+    }
+    if (args.createPayments !== undefined && args.createPayments) {
+        console.warn('💸  Creating 10 payments in card sandbox gateway account (each . is a success, each ! is a failure)');
+        let createPaymentResult;
+        for (let i = 0; i < 10; i++) {
+            createPaymentResult = await app_client_js_1.default.createPayment(apiToken);
+            if (createPaymentResult === undefined) {
+                process.stderr.write('!');
+            }
+            else {
+                process.stderr.write('.');
+            }
+        }
+    }
+    console.warn('🤓  Creating admin user for service');
+    const user = await app_client_js_1.default.createUser([account.gateway_account_id], 'admin');
+    if (user === undefined) {
+        console.error('Failed to create an admin user');
+        return;
+    }
+    console.warn('😎  Creating view-only user for service');
+    const viewOnlyUser = await app_client_js_1.default.createUser([account.gateway_account_id], 'view-only');
+    if (viewOnlyUser === undefined) {
+        console.error('Failed to create a view-only user, continuing anyway since the admin user was successfully created');
+    }
+    const { otp } = totp_generator_1.TOTP.generate(user.otp_key);
+    console.log(`📧  Email: ${user.email}`);
+    console.log(`🛂  Password: ${user.password}`);
+    console.log(`🔑  OTP key: ${user.otp_key}`);
+    console.log(`📱  OTP token: ${otp}`);
+    console.log(`💁  Service ID: ${serviceExternalID}`);
+    console.log(`💳  Card gateway account ID: ${account.external_id}`);
+    console.log(`🎫  Card API token: ${apiToken}`);
+    console.log();
+    let selfserviceUrl;
+    if (await app_client_js_1.default.isProxyHealthy('selfservice')) {
+        selfserviceUrl = app_client_js_1.default.externalUrlFor('selfservice', '/', true);
+    }
+    else {
+        selfserviceUrl = app_client_js_1.default.externalUrlFor('selfservice', '/', false);
+    }
+    copyToClipboard(user.email);
+    console.log(`📋 “${user.email}” copied to clipboard`);
+    console.log(`🌎 Opening selfservice (${selfserviceUrl}) browser`);
+    console.log();
+    (0, node_child_process_1.spawn)('open', [selfserviceUrl]);
+}
+exports.default = UserHandler;
+function copyToClipboard(email) {
+    const proc = (0, node_child_process_1.spawn)('pbcopy');
+    proc.stdin.write(email);
+    proc.stdin.end();
+}
+function parseArguments(_options) {
+    return {
+        createPayments: false
+    };
+}

package/src/commands/local.js

@@ -4,22 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (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'
-];
+const paymentlink_js_1 = __importDefault(require("./local/subcommands/paymentlink.js"));
+const url_js_1 = __importDefault(require("./local/subcommands/url.js"));
+const browse_js_1 = __importDefault(require("./local/subcommands/browse.js"));
+const db_js_1 = __importDefault(require("./local/subcommands/db.js"));
+const account_js_1 = __importDefault(require("./local/subcommands/account.js"));
+const token_js_1 = __importDefault(require("./local/subcommands/token.js"));
+const payment_js_1 = __importDefault(require("./local/subcommands/payment.js"));
+const user_js_1 = __importDefault(require("./local/subcommands/user.js"));
 var LocalCommand;
 (function (LocalCommand) {
     LocalCommand["OTP"] = "otp";
@@ -28,17 +25,18 @@ var LocalCommand;
     LocalCommand["Down"] = "down";
     LocalCommand["Restart"] = "restart";
     LocalCommand["Nuke"] = "nuke";
+    LocalCommand["PaymentLink"] = "paymentlink";
+    LocalCommand["Browse"] = "browse";
+    LocalCommand["Url"] = "url";
+    LocalCommand["DB"] = "db";
+    LocalCommand["Token"] = "token";
+    LocalCommand["Payment"] = "payment";
+    LocalCommand["Account"] = "account";
+    LocalCommand["User"] = "user";
     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) {
@@ -46,6 +44,38 @@ async function localHandler(options) {
             await (0, otp_js_1.default)(subcommandOptions);
             break;
         }
+        case LocalCommand.PaymentLink: {
+            await (0, paymentlink_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Browse: {
+            await (0, browse_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Account: {
+            await (0, account_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Url: {
+            await (0, url_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.DB: {
+            await (0, db_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Token: {
+            await (0, token_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.Payment: {
+            await (0, payment_js_1.default)(subcommandOptions);
+            break;
+        }
+        case LocalCommand.User: {
+            await (0, user_js_1.default)(subcommandOptions);
+            break;
+        }
         case LocalCommand.Up: {
             await (0, up_js_1.default)(subcommandOptions);
             break;
@@ -84,7 +114,15 @@ function parseArguments(options) {
     const subcommand = subcommandOptions.shift();
     switch (subcommand) {
         case LocalCommand.OTP: return { subcommand, subcommandOptions };
+        case LocalCommand.PaymentLink: return { subcommand, subcommandOptions };
+        case LocalCommand.Url: return { subcommand, subcommandOptions };
+        case LocalCommand.Browse: return { subcommand, subcommandOptions };
+        case LocalCommand.Account: return { subcommand, subcommandOptions };
         case LocalCommand.Up: return { subcommand, subcommandOptions };
+        case LocalCommand.DB: return { subcommand, subcommandOptions };
+        case LocalCommand.Token: return { subcommand, subcommandOptions };
+        case LocalCommand.Payment: return { subcommand, subcommandOptions };
+        case LocalCommand.User: return { subcommand, subcommandOptions };
         case LocalCommand.Launch: return { subcommand, subcommandOptions };
         case LocalCommand.Down: return { subcommand, subcommandOptions };
         case LocalCommand.Restart: return { subcommand, subcommandOptions };