@reshapr/reshapr-cli 0.0.1

package/dist/commands/config.js

@@ -0,0 +1,387 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { program } from "commander";
+import inquirer from 'inquirer';
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { openUpdateEditor } from "../utils/editor.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const configCommand = program.command('config')
+    .description(`Manage configuration plans in ${CLI_LABEL}`);
+/** List all configuration plans */
+configCommand.command('list')
+    .description('List all configuration plans')
+    .option('-s, --serviceId <id>', 'Filter by service ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching configuration plans failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing configuration plans response: ' + err.message);
+    });
+    if (data != null) {
+        if (data.length === 0) {
+            Logger.info('No configuration plans found.');
+        }
+        else {
+            Context.put('configurationPlans', data);
+            const longestName = longestCPName(data); // +1 for padding
+            const longestEndpoint = Math.max(...data.map((config) => config.backendEndpoint.length)) + 1; // +1 for padding
+            Logger.log(`${'ID'.padEnd(13, ' ')}  ${'NAME'.padEnd(longestName, ' ')} ${'SERVICE'.padEnd(14, ' ')} ${'BACKEND'.padEnd(longestEndpoint, ' ')} API_KEY  OAUTH2_CONFIG`);
+            data.forEach((config) => {
+                Logger.log(`${config.id}  ${config.name.padEnd(longestName, ' ')} ${config.serviceId.padEnd(14, ' ')} ${config.backendEndpoint.padEnd(longestEndpoint, ' ')} ${(config.apiKey != undefined ? 'Yes' : 'No').padEnd(8, ' ')} ${(config.oauth2Configuration != undefined ? 'Yes' : 'No').padEnd(13, ' ')}`);
+            });
+        }
+    }
+});
+function longestCPName(expos) {
+    return expos.reduce((max, config) => {
+        return Math.max(max, config.name.length + 1);
+    }, 0);
+}
+/** Get configuration plan by ID */
+configCommand.command('get <id>')
+    .description('Get configuration plan by ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans/${id}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching configuration plan failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const config = await response.json();
+    Context.put('configurationPlan', config);
+    Logger.info('Configuration plan details');
+    Logger.log(`ID              : ${config.id}`);
+    Logger.log(`Name            : ${config.name}`);
+    Logger.log(`Organization    : ${config.organizationId}`);
+    Logger.log(`Description     : ${config.description}`);
+    Logger.log(`Service ID      : ${config.serviceId}`);
+    Logger.log(`Backend Endpoint: ${config.backendEndpoint}`);
+    Logger.log(`Included Ops.   : ${JSON.stringify(config.includedOperations || [])}`);
+    Logger.log(`Excluded Ops.   : ${JSON.stringify(config.excludedOperations || [])}`);
+    Logger.log(`Backend Secret  : ${config.backendSecretId != undefined ? config.backendSecretId : 'No'}`);
+    Logger.log(`API Key         : ${config.apiKey != undefined ? config.apiKey : 'No'}`);
+    if (config.oauth2Configuration) {
+        Logger.bold('OAuth2:');
+        Logger.log(`  Authorization Servers: ${config.oauth2Configuration.authorizationServers.join(', ')}`);
+        Logger.log(`  JKWS URI             : ${config.oauth2Configuration.jwksUri}`);
+        if (config.oauth2Configuration.scopes) {
+            Logger.log(`  Scopes               : ${config.oauth2Configuration.scopes.join(', ')}`);
+        }
+    }
+    else {
+        Logger.log(`OAuth2          : No`);
+    }
+});
+/** Create a new configuration plan */
+configCommand.command('create <name>')
+    .description('Create a new configuration plan')
+    .requiredOption('-s, --serviceId <serviceId>', 'ID of the service')
+    .option('-d, --description <text>', 'Description of the configuration plan')
+    .requiredOption('--be, --backendEndpoint <backendEndpointURL>', 'Backend endpoint URL')
+    .option('--bs, --backendSecret <backendSecretId>', 'ID of the secret to authenticate with the backend endpoint')
+    .option('--filter', 'Filter operations to include or exclude in the configuration plan')
+    .option('--io, --includedOperations [<operation1>, <operation2>]', 'Include these operations when importing service artifact (JSON array). Takes precedence over excludedOperations.')
+    .option('--eo, --excludedOperations [<operation1>, <operation2>]', 'Exclude these operations when importing service artifact (JSON array). Only considered if no includedOperations.')
+    .option('--apiKey', 'Generate an API key for this configuration plan to secure the MCP endpoint')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (name, options) => {
+    if (!options.serviceId) {
+        Logger.error('Service ID is required to create a configuration plan.');
+        process.exit(1);
+    }
+    // Manage filter, included and excluded operations.
+    await manageInclusionsAndExclusions(options);
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            name: name,
+            serviceId: options.serviceId,
+            description: options.description,
+            backendEndpoint: options.backendEndpoint,
+            backendSecretId: options.backendSecret || undefined,
+            includedOperations: options.includedOps || undefined,
+            excludedOperations: options.excludedOps || undefined,
+            apiKey: (options.apiKey ? 'generate-me' : undefined),
+            initialAccessToken: (options.internalOAuth2 ? 'generate-me' : undefined)
+        })
+    });
+    if (!response.ok) {
+        Logger.error('Creating configuration plan failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const config = await response.json();
+    Logger.success(`Configuration plan '${config.name}' created successfully with ID: ${config.id}`);
+    Context.put('configurationPlan', config);
+    if (options.apiKey) {
+        Logger.warn(`The API Key to access future expositions is: ${config.apiKey}`);
+        Logger.warn('Make sure to store it securely, as it will not be shown again.');
+    }
+});
+/** Create a new configuration plan with oauth */
+configCommand.command('create-oauth <name>')
+    .description('Create a new configuration plan with custom OAuth2 authorization')
+    .requiredOption('-s, --serviceId <serviceId>', 'ID of the service')
+    .option('-d, --description <text>', 'Description of the configuration plan')
+    .requiredOption('--be, --backendEndpoint <backendEndpointURL>', 'Backend endpoint URL')
+    .option('--bs, --backendSecret <backendSecretId>', 'ID of the secret to authenticate with the backend endpoint')
+    .option('--filter', 'Filter operations to include or exclude in the configuration plan')
+    .option('--io, --includedOperations [<operation1>, <operation2>]', 'Include these operations when importing service artifact (JSON array). Takes precedence over excludedOperations.')
+    .option('--eo, --excludedOperations [<operation1>, <operation2>]', 'Exclude these operations when importing service artifact (JSON array). Only considered if no includedOperations.')
+    .requiredOption('--oas, --oauth2AuthorizationServers [<authorizationServer1>, <authorizationServer2>]', 'A list of OAuth2 authorization server URLs to accept tokens from')
+    .requiredOption('--oju, --oauth2jwksUri <jwksUri>', 'The JWKS URI to validate OAuth2 tokens')
+    .option('--osc, --oauth2Scopes [<scope1>, <scope2>]', 'A list of OAuth2 scopes to enforce presence in the access token')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (name, options) => {
+    if (!options.serviceId) {
+        Logger.error('Service ID is required to create a configuration plan.');
+        process.exit(1);
+    }
+    // Manage filter, included and excluded operations.
+    await manageInclusionsAndExclusions(options);
+    options.oauth2Configuration = {
+        authorizationServers: getArrayOfStrings(options.oauth2AuthorizationServers, 'oauth2AuthorizationServers'),
+        jwksUri: options.oauth2jwksUri,
+        scopes: options.oauth2Scopes ? getArrayOfStrings(options.oauth2Scopes, 'oauth2Scopes') : undefined
+    };
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            name: name,
+            serviceId: options.serviceId,
+            description: options.description,
+            backendEndpoint: options.backendEndpoint,
+            backendSecretId: options.backendSecret || undefined,
+            includedOperations: options.includedOps || undefined,
+            excludedOperations: options.excludedOps || undefined,
+            oauth2Configuration: options.oauth2Configuration
+        })
+    });
+    if (!response.ok) {
+        Logger.error('Creating configuration plan failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const config = await response.json();
+    Logger.success(`Configuration plan '${config.name}' created successfully with ID: ${config.id}`);
+    Context.put('configurationPlan', config);
+    if (options.apiKey) {
+        Logger.warn(`The API Key to access future expositions is: ${config.apiKey}`);
+        Logger.warn('Make sure to store it securely, as it will not be shown again.');
+    }
+});
+configCommand.command('update <id>')
+    .description('Update configuration plan by ID')
+    .action(async (id) => {
+    try {
+        // First, fetch the current configuration plan
+        const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans/${id}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`
+            }
+        });
+        if (!response.ok) {
+            Logger.error('Fetching configuration plan failed: ' + response.statusText);
+            process.exit(1);
+        }
+        const config = await response.json();
+        Logger.info(`Opening editor for configuration plan: ${config.name}`);
+        await openUpdateEditor(config, async (modifiedConfig) => {
+            // Enforce properties that are immutable.
+            modifiedConfig.id = config.id; // Ensure the ID remains the same.
+            modifiedConfig.organizationId = config.organizationId; // Ensure the organization ID remains the same.
+            const updateResponse = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans/${id}`, {
+                method: 'PUT',
+                headers: {
+                    'Authorization': `Bearer ${ConfigUtil.config.token}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(modifiedConfig)
+            });
+            if (!updateResponse.ok) {
+                Logger.error('Updating configuration plan failed: ' + updateResponse.statusText);
+                process.exit(1);
+            }
+            Logger.success(`Configuration plan ${id} updated successfully.`);
+        });
+    }
+    catch (error) {
+        Logger.error('Updating configuration plan failed: ' + error.message);
+        process.exit(1);
+    }
+});
+/** Renew or add ApiKey on configuration plan by ID */
+configCommand.command('renew-api-key <id>')
+    .description('Renew or add ApiKey on configuration plan by ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans/${id}/renewApiKey`, {
+        method: 'PUT',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Renewing API key failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const config = await response.json();
+    Logger.warn(`The API Key to access future expositions is: ${config.apiKey}`);
+    Logger.warn('Make sure to store it securely, as it will not be shown again.');
+    Context.put('configurationPlan', config);
+});
+/** Delete configuration plan by ID */
+configCommand.command('delete <id>')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .description('Delete configuration plan by ID')
+    .action(async (id, options) => {
+    if (!options.force) {
+        const confirm = await inquirer.prompt({
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Deleting this config plan may also remove associated expositions. Are you sure you want to proceed?',
+            default: false
+        });
+        if (!confirm.confirm) {
+            Logger.info('Deletion cancelled.');
+            return;
+        }
+    }
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans/${id}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Deleting configuration plan failed: ' + response.statusText);
+        process.exit(1);
+    }
+    Logger.success(`Configuration plan ${id} deleted successfully.`);
+});
+async function manageInclusionsAndExclusions(options) {
+    if (options.filter) {
+        // We must retrieve the available operations to filter
+        const opsResponse = await fetch(`${ConfigUtil.config.server}/api/v1/services/${options.serviceId}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`
+            }
+        });
+        if (!opsResponse.ok) {
+            Logger.error('Fetching service operations failed: ' + opsResponse.statusText);
+            process.exit(1);
+        }
+        const service = await opsResponse.json();
+        console.log(`The service ${service.name} has ${service.operations.length} operation(s) available. You can filter them to include or exclude specific operations.`);
+        const includeOrExclude = await inquirer.prompt({
+            type: 'list',
+            name: 'includeOrExclude',
+            message: 'Do you want to include or exclude operations?',
+            choices: [
+                { name: 'No', value: 'no' },
+                { name: 'Include operations', value: 'include' },
+                { name: 'Exclude operations', value: 'exclude' }
+            ]
+        });
+        if (includeOrExclude.includeOrExclude === 'no') {
+            options.includedOps = [];
+            options.excludedOps = [];
+        }
+        else {
+            const opsChoices = service.operations.map((op) => ({
+                name: op.name,
+                value: op.name
+            }));
+            // Sort by operation path if OpenAPI.
+            if (service.type === 'REST') {
+                opsChoices.sort(function (x, y) {
+                    const pathX = x.value.split('/')[1];
+                    const pathY = y.value.split('/')[1];
+                    return pathX.localeCompare(pathY);
+                });
+            }
+            else {
+                // Sort alphabetically for other types.
+                opsChoices.sort();
+            }
+            const selectedOps = await inquirer.prompt({
+                type: 'checkbox',
+                name: includeOrExclude.includeOrExclude === 'include' ? 'includedOps' : 'excludedOps',
+                message: `Select operations to ${includeOrExclude.includeOrExclude}:`,
+                choices: opsChoices,
+                loop: false,
+                pageSize: 10
+            });
+            options[includeOrExclude.includeOrExclude === 'include' ? 'includedOps' : 'excludedOps'] =
+                selectedOps[includeOrExclude.includeOrExclude === 'include' ? 'includedOps' : 'excludedOps'];
+        }
+    }
+    else {
+        if (options.includedOperations) {
+            let operations = getArrayOfStrings(options.includedOperations, 'includedOperations');
+            options.includedOps = operations;
+        }
+        if (!options.includedOperations && options.excludedOperations) {
+            let operations = getArrayOfStrings(options.excludedOperations, 'excludedOperations');
+            options.excludedOps = operations;
+        }
+    }
+}
+function getArrayOfStrings(input, name) {
+    if (Array.isArray(input)) {
+        return input;
+    }
+    else {
+        try {
+            const parsed = JSON.parse(input);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            else {
+                throw new Error('Not an array');
+            }
+        }
+        catch (err) {
+            Logger.error(`Input must be a JSON array of strings for ${name}.`);
+            process.exit(1);
+        }
+    }
+    return [];
+}

package/dist/commands/expo.js

@@ -0,0 +1,222 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { program } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { ageFrom } from "../utils/age.js";
+import { formatEndpoint } from "../utils/format.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const expoCommand = program.command('expo')
+    .description(`Manage expositions in ${CLI_LABEL}`);
+/* List all expositions */
+expoCommand.command('list')
+    .description('List all expositions')
+    .option('-a, --all', 'Display also inactive expositions')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    if (options.all) {
+        // If --all option is provided, list all expositions (active and inactive)
+        const response = await fetch(`${ConfigUtil.config.server}/api/v1/expositions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`
+            }
+        });
+        if (!response.ok) {
+            Logger.error('Fetching expositions failed: ' + response.statusText);
+            process.exit(1);
+        }
+        const data = await response.json().catch(err => {
+            Logger.error('Error parsing expositions response: ' + err.message);
+        });
+        if (data.length === 0) {
+            Logger.info('No expositions found.');
+        }
+        else {
+            Context.put('expositions', data);
+            const longestName = longestServiceName(data) + 1; // +1 for padding
+            const longestBackend = longestBackendEndpoint(data) + 1; // +1 for padding
+            Logger.log(`${'ID'.padEnd(13, ' ')}  ${'SERVICE'.padEnd(longestName, ' ')} ${'BACKEND'.padEnd(longestBackend, ' ')} AGE`);
+            data.forEach((expo) => {
+                Logger.log(`${expo.id}  ${(expo.service.name + ':' + expo.service.version).padEnd(longestName, ' ')} ${expo.configurationPlan.backendEndpoint.padEnd(longestBackend, ' ')} ${ageFrom(expo.createdOn)}`);
+            });
+        }
+    }
+    else {
+        // Default is to list only active expositions
+        const response = await fetch(`${ConfigUtil.config.server}/api/v1/expositions/active`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`
+            }
+        });
+        if (!response.ok) {
+            Logger.error('Fetching expositions failed: ' + response.statusText);
+            process.exit(1);
+        }
+        const data = await response.json().catch(err => {
+            Logger.error('Error parsing expositions response: ' + err.message);
+        });
+        if (data.length === 0) {
+            Logger.info('No active expositions found. Check inactive expositions with the --all option.');
+        }
+        else {
+            Context.put('expositions', data);
+            const longestName = longestServiceName(data) + 1; // +1 for padding
+            const longestBackend = longestBackendEndpoint(data) + 1; // +1 for padding
+            const longestEndpoints = longestGatewaysFQDNs(data) + 1; // +1 for padding
+            Logger.log(`${'ID'.padEnd(13, ' ')}  ${'SERVICE'.padEnd(longestName, ' ')} ${'BACKEND'.padEnd(longestBackend, ' ')} ${'ENDPOINTS'.padEnd(longestEndpoints, ' ')} AGE`);
+            data.forEach((expo) => {
+                let allFqdns = uniqueFQDNs(expo.gateways);
+                Logger.log(`${expo.id}  ${(expo.service.name + ':' + expo.service.version).padEnd(longestName, ' ')} ${expo.configurationPlan.backendEndpoint.padEnd(longestBackend, ' ')} ${allFqdns.join(',').padEnd(longestEndpoints, ' ')} ${ageFrom(expo.createdOn)}`);
+            });
+        }
+    }
+});
+function longestServiceName(expos) {
+    return expos.reduce((max, expo) => {
+        return Math.max(max, expo.service.name.length + expo.service.version.length + 1);
+    }, 0);
+}
+function longestBackendEndpoint(expos) {
+    return expos.reduce((max, expo) => {
+        return Math.max(max, expo.configurationPlan.backendEndpoint ? expo.configurationPlan.backendEndpoint.length : 0);
+    }, 0);
+}
+function uniqueFQDNs(gateways) {
+    let allFqdns = [];
+    gateways.forEach(gateway => {
+        gateway.fqdns.filter(fqdn => !allFqdns.includes(fqdn)).forEach(fqdn => allFqdns.push(fqdn));
+    });
+    return allFqdns;
+}
+function longestGatewaysFQDNs(expos) {
+    return expos.reduce((max, expo) => {
+        return Math.max(max, uniqueFQDNs(expo.gateways).join(',').length);
+    }, 0);
+}
+/** Get exposition by ID */
+expoCommand.command('get <id>')
+    .description('Get details of an exposition by ID')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/expositions/${id}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching exposition failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const exposition = await response.json();
+    Context.put('exposition', exposition);
+    await displayExpositionDetails(exposition);
+});
+/** Create a new exposition */
+expoCommand.command('create')
+    .description('Create a new exposition')
+    .requiredOption('-c, --configuration <id>', 'Configuration Plan ID to use')
+    .requiredOption('-g, --gateway-group <id>', 'Gateway Group ID to use')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/expositions`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            configurationPlanId: options.configuration,
+            gatewayGroupId: options.gatewayGroup
+        })
+    });
+    if (!response.ok) {
+        Logger.error('Failed to create exposition: ' + response.statusText);
+        if (response.status === 429) {
+            Logger.error('Exposition creation quota exceeded. Check your quotas.');
+        }
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing exposition creation response: ' + err.message);
+        process.exit(1);
+    });
+    Context.put('exposition', data);
+    Logger.success(`Exposition created successfully with ID: ${data.id}`);
+    await displayExpositionDetails(data);
+});
+/** Delete exposition by ID */
+expoCommand.command('delete <id>')
+    .description('Delete an exposition by ID')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/expositions/${id}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Deleting exposition failed: ' + response.statusText);
+        process.exit(1);
+    }
+    Logger.success(`Exposition ${id} deleted successfully.`);
+});
+async function displayExpositionDetails(exposition) {
+    Logger.info('Exposition details');
+    Logger.log(`ID          : ${exposition.id}`);
+    Logger.log(`Created on  : ${exposition.createdOn}`);
+    Logger.log(`Organization: ${exposition.organizationId}`);
+    Logger.bold('Service:');
+    Logger.log(`  ID     : ${exposition.service.id}`);
+    Logger.log(`  Name   : ${exposition.service.name}`);
+    Logger.log(`  Version: ${exposition.service.version}`);
+    Logger.log(`  Type   : ${exposition.service.type}`);
+    Logger.bold('Configuration Plan');
+    Logger.log(`  ID             : ${exposition.configurationPlan.id}`);
+    Logger.log(`  Name           : ${exposition.configurationPlan.name}`);
+    Logger.log(`  BackendEndpoint: ${exposition.configurationPlan.backendEndpoint}`);
+    Logger.log(`  Included Ops.  : ${JSON.stringify(exposition.configurationPlan.includedOperations || [])}`);
+    Logger.log(`  Excluded Ops.  : ${JSON.stringify(exposition.configurationPlan.excludedOperations || [])}`);
+    Logger.bold('Gateway Group');
+    Logger.log(`  ID    : ${exposition.gatewayGroup.id}`);
+    Logger.log(`  Name  : ${exposition.gatewayGroup.name}`);
+    Logger.log(`  Labels: ${JSON.stringify(exposition.gatewayGroup.labels)}`);
+    // Now check if acctive and print active endpoints if any.
+    const activeResponse = await fetch(`${ConfigUtil.config.server}/api/v1/expositions/active/${exposition.id}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (activeResponse.status === 404) {
+        Logger.warn(`No active exposition found for the Exposition ${exposition.id}. Maybe there's no running Gateway at the moment?`);
+        process.exit(0);
+    }
+    const activeExpositions = await activeResponse.json();
+    Context.put('gateways', activeExpositions.gateways);
+    let allFqdns = uniqueFQDNs(activeExpositions.gateways);
+    Context.put('endpoints', allFqdns.map(fqdn => formatEndpoint(fqdn, exposition.organizationId, exposition.service.name, exposition.service.version)));
+    Logger.bold('Gateway Endpoints');
+    activeExpositions.gateways.forEach((gateway) => {
+        Logger.log(`  - ID       : ${gateway.id}`);
+        Logger.log(`    Name     : ${gateway.name}`);
+        Logger.log(`    Endpoints: ${gateway.fqdns.map((fqdn) => formatEndpoint(fqdn, exposition.organizationId, exposition.service.name, exposition.service.version))
+            .join(', ')}`);
+    });
+}