@reshapr/reshapr-cli 0.0.1

package/dist/commands/gateway-group.js

@@ -0,0 +1,108 @@
+/*
+ * 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 { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const gatewayGroupCommand = program.command('gateway-group')
+    .description(`Manage gateway groups in ${CLI_LABEL}`);
+/* List all gateway groups */
+gatewayGroupCommand.command('list')
+    .description('List all gateway groups')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/gatewayGroups`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching gateway groups failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json();
+    if (data.length === 0) {
+        Logger.info('No gateway groups found.');
+    }
+    else {
+        Context.put('gatewayGroups', data);
+        const longestName = longestGroupName(data) + 1; // +1 for padding
+        const longestGroupOrganization = longestGroupOrganizationName(data) + 1; // +1 for padding
+        Logger.log(`${'ID'.padEnd(13, ' ')}  ${'ORG'.padEnd(longestGroupOrganization, ' ')} ${'NAME'.padEnd(longestName, ' ')} ${'LABELS'.padEnd(60, ' ')}`);
+        data.forEach((group) => {
+            Logger.log(`${group.id.padEnd(13, ' ')}  ${group.organizationId.padEnd(longestGroupOrganization, ' ')} ${group.name.padEnd(longestName, ' ')} ${JSON.stringify(group.labels).padEnd(60, ' ')}`);
+        });
+    }
+});
+function longestGroupName(groups) {
+    return groups.reduce((max, group) => {
+        return Math.max(max, group.name.length);
+    }, 0);
+}
+function longestGroupOrganizationName(groups) {
+    return groups.reduce((max, group) => {
+        return Math.max(max, group.organizationId ? group.organizationId.length : 0);
+    }, 0);
+}
+/** Create a new gateway group */
+gatewayGroupCommand.command('create <name>')
+    .description('Create a new gateway group')
+    .option('-l, --labels <labels>', 'JSON map of key-values labels for the gateway group')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (name, options) => {
+    let labels = options.labels ? JSON.parse(options.labels) : {};
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/gatewayGroups`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            name: name,
+            labels: labels
+        })
+    });
+    if (!response.ok) {
+        if (response.status === 429) {
+            Logger.error('Gateway group creation quota exceeded. Check your quotas.');
+        }
+        else {
+            Logger.error('Creating gateway group failed: ' + response.statusText);
+        }
+        process.exit(1);
+    }
+    const data = await response.json();
+    Logger.success(`Gateway group '${data.name}' created successfully with ID: ${data.id}`);
+    Context.put('gatewayGroup', data);
+});
+/** Delete a gateway group by ID */
+gatewayGroupCommand.command('delete <id>')
+    .description('Delete a gateway group by ID')
+    .action(async (id) => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/gatewayGroups/${id}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Deleting gateway group failed: ' + response.statusText);
+        process.exit(1);
+    }
+    Logger.success(`Gateway group with ID '${id}' deleted successfully.`);
+});

package/dist/commands/import.js

@@ -0,0 +1,230 @@
+/*
+ * 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 fs from 'node:fs';
+import yoctoSpinner from 'yocto-spinner';
+import { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { formatEndpoint } from "../utils/format.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+const DEFAULT_GATEWAY_GROUP_ID = '1'; // Default Gateway Group ID, can be changed later
+export const importCommand = new Command('import')
+    .description(`Import an artifact into ${CLI_LABEL}`)
+    .option('-f, --file <file>', 'Path to the artifact file to import')
+    .option('-u, --url <url>', 'URL of the artifact to import')
+    .option('-s, --secret <artifactSecret>', 'Use a secret to authenticate the artifact to import')
+    .option('--sn, --serviceName <name>', 'Set the service name (mandatory for GraphQL schema imports)')
+    .option('--sv, --serviceVersion <version>', 'Set the service version (mandatory for GraphQL schema imports)')
+    .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('--be, --backendEndpoint <backendEndpointURL>', 'Directly expose the artifact on a Gateway using a backend endpoint')
+    .option('--bs, --backendSecret <backendSecretId>', 'ID of a secret to authenticate exposed MCP with backend endpoint')
+    .option('--apiKey', 'Generate an API key for the configuration plan to secure the MCP endpoint')
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async (options) => {
+    if (!options.file && !options.url) {
+        Logger.error('You must provide either a file path or a URL to import.');
+        process.exit(1);
+    }
+    let body;
+    if (options.file) {
+        if (!fs.existsSync(options.file)) {
+            Logger.error(`File not found: ${options.file}`);
+            process.exit(1);
+        }
+        // We should encode in multipart/form-data
+        body = new FormData();
+        body.append('file', new Blob([fs.readFileSync(options.file)]), options.file.split('/').pop());
+        body.append('mainArtifact', 'true');
+    }
+    else if (options.url) {
+        // We should encode in application/x-www-form-urlencoded
+        body = new URLSearchParams();
+        body.append('url', options.url);
+        body.append('mainArtifact', 'true');
+        if (options.secret) {
+            body.append('secretName', options.secret);
+        }
+    }
+    if (options.serviceName) {
+        if (!options.serviceVersion || options.serviceName.trim() === '') {
+            Logger.error('Service version cannot be empty when service name is provided.');
+            process.exit(1);
+        }
+        body.append('serviceName', options.serviceName);
+    }
+    if (options.serviceVersion) {
+        if (!options.serviceName || options.serviceName.trim() === '') {
+            Logger.error('Service name cannot be empty when service version is provided.');
+            process.exit(1);
+        }
+        body.append('serviceVersion', options.serviceVersion);
+    }
+    if (options.includedOperations) {
+        let operations = getArrayOfStrings(options.includedOperations, 'includedOperations');
+        for (const op of operations) {
+            body.append('includedOperations', op);
+        }
+    }
+    if (!options.includedOperations && options.excludedOperations) {
+        let operations = getArrayOfStrings(options.excludedOperations, 'excludedOperations');
+        for (const op of operations) {
+            body.append('excludedOperations', op);
+        }
+    }
+    const spinner = yoctoSpinner({ text: 'Importing artifact...' }).start();
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/artifacts`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`,
+        },
+        body: body
+    });
+    if (!response.ok) {
+        Logger.error('Import failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Failed to parse response: ' + err.message);
+        process.exit(1);
+    });
+    spinner.stop();
+    Context.put('service', data);
+    Logger.success('Import successful!');
+    Logger.info(`Discovered Service ${data.name} with ID: ${data.id}`);
+    if (options.backendEndpoint) {
+        await exposeService(options, data);
+    }
+});
+async function exposeService(options, service) {
+    if (options.backendEndpoint) {
+        const backendEndpoint = options.backendEndpoint;
+        // First create a Configuration Plan.
+        const planResponse = await fetch(`${ConfigUtil.config.server}/api/v1/configurationPlans`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                serviceId: service.id,
+                name: `default-plan for ${service.name}`,
+                description: `Configuration plan for ${service.name} on ${backendEndpoint}`,
+                backendEndpoint: options.backendEndpoint,
+                backendSecretId: options.backendSecret || undefined,
+                apiKey: (options.apiKey ? 'generate-me' : undefined),
+                initialAccessToken: (options.internalOAuth2 ? 'generate-me' : undefined)
+            })
+        });
+        if (!planResponse.ok) {
+            Logger.error('Failed to create a Config Plan for service: ' + planResponse.statusText);
+            process.exit(1);
+        }
+        const planData = await planResponse.json();
+        Context.put('configurationPlan', planData);
+        if (options.apiKey) {
+            Logger.warn(`The API Key to access future expositions is: ${planData.apiKey}`);
+            Logger.warn('Make sure to store it securely, as it will not be shown again.');
+        }
+        // Then expose the config plan on the default Gateway Group.
+        const exposeResponse = await fetch(`${ConfigUtil.config.server}/api/v1/expositions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${ConfigUtil.config.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                gatewayGroupId: DEFAULT_GATEWAY_GROUP_ID,
+                configurationPlanId: planData.id
+            })
+        });
+        if (!exposeResponse.ok) {
+            Logger.error('Failed to expose configuration: ' + exposeResponse.statusText);
+            if (exposeResponse.status === 429) {
+                Logger.error('Exposition creation quota exceeded. Check your quotas.');
+            }
+            process.exit(1);
+        }
+        const exposeData = await exposeResponse.json().catch(err => {
+            Logger.error('Failed to parse exposition response: ' + err.message);
+            process.exit(1);
+        });
+        Logger.success('Exposition done!');
+        Context.put('exposition', exposeData);
+        await getActiveExposition(exposeData);
+    }
+}
+async function getActiveExposition(exposition) {
+    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);
+    }
+    if (!activeResponse.ok) {
+        Logger.error('Failed to retrieve active exposition: ' + activeResponse.statusText);
+        process.exit(1);
+    }
+    const data = await activeResponse.json().catch(err => {
+        Logger.error('Failed to parse active exposition response: ' + err.message);
+        process.exit(1);
+    });
+    Logger.success('Exposition is now active!');
+    Logger.log(`Exposition ID  : ${data.id}`);
+    Logger.log(`Organization   : ${data.organizationId}`);
+    Logger.log(`Created on     : ${data.createdOn}`);
+    Logger.log(`Service ID     : ${data.service.id}`);
+    Logger.log(`Service Name   : ${data.service.name}`);
+    Logger.log(`Service Version: ${data.service.version}`);
+    Logger.log(`Service Type   : ${data.service.type} -> ${data.configurationPlan.backendEndpoint}`);
+    let allFqdns = uniqueFQDNs(data.gateways);
+    Context.put('endpoints', uniqueFQDNs(data.gateways).map(fqdn => formatEndpoint(fqdn, exposition.organizationId, exposition.service.name, exposition.service.version)));
+    Logger.log(`Endpoints      : ${allFqdns.map((fqdn) => formatEndpoint(fqdn, data.organizationId, data.service.name, data.service.version))
+        .join(', ')}`);
+}
+function uniqueFQDNs(gateways) {
+    let allFqdns = [];
+    gateways.forEach(gateway => {
+        gateway.fqdns.filter(fqdn => !allFqdns.includes(fqdn)).forEach(fqdn => allFqdns.push(fqdn));
+    });
+    return allFqdns;
+}
+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/index.js

@@ -0,0 +1,27 @@
+/*
+ * 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.
+ */
+export { loginCommand } from './login.js';
+export { infoCommand } from './info.js';
+export { logoutCommand } from './logout.js';
+export { importCommand } from './import.js';
+export { attachCommand } from './attach.js';
+export { serviceCommand } from './service.js';
+export { secretCommand } from './secret.js';
+export { expoCommand } from './expo.js';
+export { configCommand } from './config.js';
+export { gatewayGroupCommand } from './gateway-group.js';
+export { tokenCommand } from './api-token.js';
+export { quotasCommand } from './quotas.js';

package/dist/commands/info.js

@@ -0,0 +1,47 @@
+/*
+ * 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 { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { CLI_LABEL } from '../constants.js';
+export const infoCommand = new Command('info')
+    .description(`Display information about current context and the ${CLI_LABEL} Server`)
+    .action(async () => {
+    Logger.info('User Information');
+    console.log(`  User        : ${ConfigUtil.config.username}`);
+    console.log(`  Organization: ${ConfigUtil.config.org}`);
+    console.log(`  Server      : ${ConfigUtil.config.server}`);
+    const response = await fetch(`${ConfigUtil.config.server}/api/config`, {
+        method: 'GET'
+    });
+    if (!response.ok) {
+        Logger.error('Failed to fetch server information: ' + response.statusText);
+        process.exit(1);
+    }
+    response.json().then(async (data) => {
+        Logger.info('Server Information');
+        console.log(`  Version     : ${data.version}`);
+        console.log(`  Build time  : ${data.buildTimestamp}`);
+        console.log(`  Mode        : ${data.mode}`);
+        console.log(`  Internal IDP: ${data.internalIDPUrl}`);
+        if (data.authenticationConfig && data.authenticationConfig.enabled) {
+            console.log(`  OAuth2 IDP : ${data.authenticationConfig.url}/${data.authenticationConfig.realm}`);
+        }
+    }).catch(err => {
+        Logger.error('Failed to parse server information: ' + err.message);
+        process.exit(1);
+    });
+});

package/dist/commands/login.js

@@ -0,0 +1,164 @@
+/*
+ * 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 http from 'http';
+import url from 'url';
+import open from 'open';
+import getPort, { portNumbers } from 'get-port';
+import { Command } from "commander";
+import inquirer from 'inquirer';
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from '../utils/config.js';
+import { CLI_LABEL } from '../constants.js';
+export const loginCommand = new Command('login')
+    .description(`Login to ${CLI_LABEL}`)
+    .option('-u, --username <username>', `Your ${CLI_LABEL} username`)
+    .option('-p, --password <password>', `Your ${CLI_LABEL} password`)
+    .option('-t, --token <token>', `Your ${CLI_LABEL} authentication token`)
+    .option('-o, --org <org>', `Your ${CLI_LABEL} organization name`)
+    .option('-s, --server <server>', `Your ${CLI_LABEL} Control Plane URL`, 'https://app.resphar.io')
+    .option('-k, --insecure', 'Skip SSL certificate validation')
+    .action(async (options) => {
+    // First validate server URL and fetch server configuration.
+    const configResponse = await fetch(`${options.server}/api/config`, {
+        method: 'GET'
+    }).catch(err => {
+        Logger.error('Failed to connect to the server. Check URL.');
+        process.exit(1);
+    });
+    const configData = await configResponse.json().catch(err => {
+        Logger.error('Failed to parse server configuration: ' + err.message);
+        process.exit(1);
+    });
+    if (configData.mode === 'on-premises') {
+        await handleOnPremisesLogin(options);
+        //await handleSaaSLogin(options);
+    }
+    else if (configData.mode === 'saas') {
+        await handleSaaSLogin(options);
+    }
+});
+async function handleOnPremisesLogin(options) {
+    // Handle on-premises login logic here if needed.
+    if (!options.username) {
+        const username = await inquirer.prompt({
+            type: 'input',
+            name: 'username',
+            message: `Enter your ${CLI_LABEL} username:`,
+            validate: (input) => {
+                if (!input) {
+                    return 'Username is required';
+                }
+                return true;
+            }
+        });
+        options.username = username.username;
+    }
+    if (!options.password) {
+        const password = await inquirer.prompt({
+            type: 'password',
+            name: 'password',
+            message: `Enter your ${CLI_LABEL} password:`,
+            validate: (input) => {
+                if (!input) {
+                    return 'Password is required';
+                }
+                return true;
+            }
+        });
+        options.password = password.password;
+    }
+    // Here you call a login function to authenticate the user.
+    Logger.info(`Logging in to ${CLI_LABEL} at ${options.server}...`);
+    const response = await fetch(`${options.server}/auth/login/reshapr`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            username: options.username,
+            password: options.password
+        })
+    });
+    if (!response.ok) {
+        Logger.error('Login failed: ' + response.statusText);
+        process.exit(1);
+    }
+    response.text().then(data => {
+        Logger.success('Login successful!');
+        Logger.info(`Welcome, ${options.username}!`);
+        // Here you would typically save the authentication token or session.
+        let config = {
+            username: options.username,
+            server: options.server,
+            insecure: options.insecure,
+            token: data // Assuming the response contains a token.
+        };
+        ConfigUtil.writeConfig(config);
+    }).catch(err => {
+        Logger.error('Error parsing response: ' + err.message);
+        process.exit(1);
+    });
+}
+async function handleSaaSLogin(options) {
+    // Prepare a token for reception.
+    let token = null;
+    // Start starting a lightweight web server to handle OAuth2 login.
+    const server = http.createServer((req, res) => {
+        // Handle Authentication callback here. Parse the URL.
+        const parsedUrl = url.parse(req.url || '', true);
+        // Get query parts of the URL.
+        const query = parsedUrl.query;
+        if (query.token && query.token.length > 0) {
+            token = query.token;
+            Logger.success('Login successful!');
+            const tokenPayload = token.split('.')[1];
+            const decodedPayload = Buffer.from(tokenPayload, 'base64').toString('utf8');
+            const username = JSON.parse(decodedPayload).sub || 'unknown';
+            Logger.info(`Welcome, ${username}!`);
+            // Here you would typically save the authentication token or session.
+            let config = {
+                username: username,
+                server: options.server,
+                insecure: options.insecure,
+                token: token
+            };
+            ConfigUtil.writeConfig(config);
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('Login successful! You can close this window now.');
+        }
+        else {
+            Logger.error('Login failed: No token received.');
+            res.writeHead(400, { 'Content-Type': 'text/plain' });
+            res.end(`Login failed: No token received. Please login on ${options.server} before trying again.`);
+        }
+        process.exit(0);
+    });
+    server.on('error', (err) => {
+        Logger.error('Failed to start server for OAuth2 login: ' + err.message);
+        process.exit(1);
+    });
+    const localPort = await getPort({ port: portNumbers(5556, 5599) });
+    server.listen(localPort, () => {
+        Logger.info(`Listening for OAuth2 callback on http://localhost:${localPort}`);
+    });
+    // Opens the URL in the default browser.
+    await open(`${options.server}/auth/login/saas?redirect_uri=http://localhost:${localPort}`, {
+        wait: true
+    });
+    server.close(() => {
+        Logger.info('Server closed after handling OAuth2 callback.');
+    });
+}

package/dist/commands/logout.js

@@ -0,0 +1,25 @@
+/*
+ * 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 { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { CLI_LABEL } from '../constants.js';
+export const logoutCommand = new Command('logout')
+    .description(`Logout from ${CLI_LABEL}`)
+    .action(async (options) => {
+    ConfigUtil.deleteConfig();
+    Logger.success('You have been logged out successfully.');
+});

package/dist/commands/quotas.js

@@ -0,0 +1,60 @@
+/*
+ * 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 { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { ConfigUtil } from "../utils/config.js";
+import { Context } from "../utils/context.js";
+import { CLI_LABEL } from '../constants.js';
+export const quotasCommand = new Command('quotas')
+    .description(`List and check your ${CLI_LABEL} quotas`)
+    .option('-o, --output <format>', 'Output format (json, yaml)')
+    .action(async () => {
+    const response = await fetch(`${ConfigUtil.config.server}/api/v1/quotas`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${ConfigUtil.config.token}`
+        }
+    });
+    if (!response.ok) {
+        Logger.error('Fetching quotas failed: ' + response.statusText);
+        process.exit(1);
+    }
+    const data = await response.json().catch(err => {
+        Logger.error('Error parsing quotas response: ' + err.message);
+    });
+    if (data.length === 0) {
+        Logger.info('No quotas found.');
+    }
+    else {
+        Context.put('quotas', data);
+        const longestMetric = longestQuotaMetric(data) + 1; // +1 for padding
+        const longestOrganization = longestQuotaOrganization(data) + 1;
+        Logger.log(`${'ORG'.padEnd(longestOrganization, ' ')} ${'METRIC'.padEnd(longestMetric, ' ')} ${'ENABLED'.padEnd(8, ' ')} ${'LIMIT'.padEnd(6, ' ')} ${'REMAINING'.padEnd(10, ' ')}`);
+        data.forEach((quota) => {
+            Logger.log(`${quota.organizationId.padEnd(longestOrganization, ' ')} ${quota.metric.padEnd(longestMetric, ' ')} ${(quota.enabled ? 'Y' : 'N').padEnd(8, ' ')} ${quota.limit.toString().padEnd(6, ' ')} ${quota.remaining.toString().padEnd(10, ' ')}`);
+        });
+    }
+});
+const longestQuotaMetric = (quotas) => {
+    return quotas.reduce((max, quota) => {
+        return Math.max(max, quota.metric.length);
+    }, 0);
+};
+const longestQuotaOrganization = (quotas) => {
+    return quotas.reduce((max, quota) => {
+        return Math.max(max, quota.organizationId.length);
+    }, 0);
+};