@dishantlangayan/sc-plugin-broker 0.1.0

package/dist/commands/broker/login/basic.js

@@ -0,0 +1,293 @@
+import { AuthType, BrokerAuthError, BrokerAuthErrorCode, ScCommand, } from '@dishantlangayan/sc-cli-core';
+import { Flags } from '@oclif/core';
+import * as process from 'node:process';
+import * as readline from 'node:readline';
+export default class BrokerLoginBasic extends ScCommand {
+    static args = {};
+    static description = `Login to a Solace Event Broker using Basic authentication.
+
+Stores broker credentials securely using encrypted local storage.
+Credentials are base64-encoded and encrypted before storage.
+
+If a broker with the same name already exists, you'll be prompted to overwrite.
+
+Required SEMP permissions: Varies by operations you intend to perform`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --semp-url=https://localhost --semp-port=8080',
+        '<%= config.bin %> <%= command.id %> --broker-name=ci-broker --semp-url=http://192.168.1.100 --semp-port=8080 --no-prompt',
+        '<%= config.bin %> <%= command.id %> --broker-name=default-broker --semp-url=https://broker.example.com --semp-port=943 --set-default',
+    ];
+    static flags = {
+        'broker-name': Flags.string({
+            char: 'b',
+            description: 'Name/identifier for the broker',
+            required: true,
+        }),
+        'no-prompt': Flags.boolean({
+            default: false,
+            description: 'Read credentials from SC_SEMP_USERNAME and SC_SEMP_PASSWORD environment variables',
+        }),
+        'semp-port': Flags.integer({
+            char: 'p',
+            description: 'SEMP port number (1-65535)',
+            required: true,
+        }),
+        'semp-url': Flags.string({
+            char: 'u',
+            description: 'SEMP endpoint URL (must start with http:// or https://)',
+            required: true,
+        }),
+        'set-default': Flags.boolean({
+            char: 'd',
+            default: false,
+            description: 'Set this broker as the default',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(BrokerLoginBasic);
+        try {
+            // Get broker auth manager
+            const brokerAuthManager = await this.getBrokerAuthManager();
+            // Validate inputs and get broker name
+            this.validateInputs(flags);
+            const brokerName = flags['broker-name'];
+            // Handle existing broker
+            const isUpdate = await this.handleExistingBroker(brokerAuthManager, brokerName, flags['no-prompt']);
+            // Obtain credentials
+            const { password, username } = await this.obtainCredentials(flags['no-prompt']);
+            // Encode credentials and create broker config
+            const accessToken = this.encodeBasicAuth(username, password);
+            const brokerAuth = this.createBrokerAuth(flags, brokerName, accessToken);
+            // Store broker configuration
+            await (isUpdate ? brokerAuthManager.updateBroker(brokerName, brokerAuth) : brokerAuthManager.addBroker(brokerAuth));
+            // Set as default if requested
+            if (flags['set-default']) {
+                await brokerAuthManager.setDefaultBroker(brokerName);
+            }
+            // Display success message
+            this.displaySuccessMessage(isUpdate, brokerName, flags['set-default']);
+            return brokerAuth;
+        }
+        catch (error) {
+            this.handleLoginError(error);
+        }
+    }
+    /**
+     * Creates broker authentication configuration object
+     */
+    createBrokerAuth(flags, brokerName, accessToken) {
+        return {
+            accessToken,
+            authType: AuthType.BASIC,
+            name: brokerName,
+            sempEndpoint: flags['semp-url'],
+            sempPort: flags['semp-port'],
+        };
+    }
+    /**
+     * Displays success message after login
+     */
+    displaySuccessMessage(isUpdate, brokerName, setDefault) {
+        const action = isUpdate ? 'updated' : 'logged in to';
+        this.log(`Successfully ${action} broker '${brokerName}'`);
+        if (setDefault) {
+            this.log('Set as default broker.');
+        }
+    }
+    /**
+     * Encodes username and password to base64 for basic authentication
+     */
+    encodeBasicAuth(username, password) {
+        const credentials = `${username}:${password}`;
+        return Buffer.from(credentials, 'utf8').toString('base64');
+    }
+    /**
+     * Checks if broker exists and handles overwrite confirmation
+     */
+    async handleExistingBroker(brokerAuthManager, brokerName, noPrompt) {
+        const exists = await brokerAuthManager.brokerExists(brokerName);
+        if (!exists) {
+            return false;
+        }
+        // If no-prompt, assume yes to overwrite
+        if (noPrompt) {
+            return true;
+        }
+        const shouldOverwrite = await this.promptForConfirmation(`Broker '${brokerName}' already exists. Do you want to overwrite the credentials?`);
+        if (!shouldOverwrite) {
+            this.log('Login cancelled.');
+            this.exit(0);
+        }
+        return true;
+    }
+    /**
+     * Handles errors during login process
+     */
+    handleLoginError(error) {
+        if (error instanceof BrokerAuthError) {
+            switch (error.code) {
+                case BrokerAuthErrorCode.FILE_WRITE_ERROR: {
+                    this.error('Failed to save broker configuration. Please check file permissions.');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_ACCESS_TOKEN: {
+                    this.error('Failed to encode credentials. Please check your username and password.');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_ENDPOINT: {
+                    this.error('Invalid SEMP endpoint URL format. URL must start with http:// or https://');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_NAME: {
+                    this.error('Invalid broker name. Please provide a valid broker name.');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_PORT: {
+                    this.error('Invalid port number. Port must be between 1 and 65535.');
+                    break;
+                }
+                case BrokerAuthErrorCode.NOT_INITIALIZED: {
+                    this.error('Failed to initialize broker authentication manager.');
+                    break;
+                }
+                default: {
+                    this.error(`Login failed: ${error.message}`);
+                    break;
+                }
+            }
+        }
+        if (error instanceof Error && error.message === 'Cancelled by user') {
+            this.error('Login cancelled.');
+        }
+        // Re-throw unexpected errors
+        throw error;
+    }
+    /**
+     * Obtains credentials from environment variables or user prompts
+     */
+    async obtainCredentials(noPrompt) {
+        if (noPrompt) {
+            const username = process.env.SC_SEMP_USERNAME || '';
+            const password = process.env.SC_SEMP_PASSWORD || '';
+            if (!username || !password) {
+                this.error('SC_SEMP_USERNAME and SC_SEMP_PASSWORD environment variables must be set when using --no-prompt flag.');
+            }
+            return { password, username };
+        }
+        const username = await this.promptForUsername();
+        const password = await this.promptForPassword();
+        return { password, username };
+    }
+    /**
+     * Prompts user for confirmation with Y/n (default Yes)
+     */
+    async promptForConfirmation(message) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${message} (Y/n): `, (answer) => {
+                rl.close();
+                const normalized = answer.trim().toLowerCase();
+                // Default to yes if empty, accept y/yes as confirmation
+                const confirmed = normalized === '' || normalized === 'y' || normalized === 'yes';
+                resolve(confirmed);
+            });
+        });
+    }
+    /**
+     * Prompts user for password with hidden input
+     */
+    async promptForPassword() {
+        return new Promise((resolve, reject) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            process.stdout.write('SEMP Password: ');
+            let password = '';
+            const { stdin } = process;
+            // Hide input by setting raw mode
+            if (stdin.isTTY) {
+                stdin.setRawMode(true);
+            }
+            const onData = (char) => {
+                const charStr = char.toString();
+                // Enter key
+                if (charStr === '\n' || charStr === '\r' || charStr === '\r\n') {
+                    process.stdout.write('\n');
+                    if (stdin.isTTY) {
+                        stdin.setRawMode(false);
+                    }
+                    stdin.removeListener('data', onData);
+                    rl.close();
+                    if (!password) {
+                        reject(new Error('Password cannot be empty'));
+                        return;
+                    }
+                    resolve(password);
+                    return;
+                }
+                // Ctrl+C
+                if (charStr === '\u0003') {
+                    process.stdout.write('\n');
+                    if (stdin.isTTY) {
+                        stdin.setRawMode(false);
+                    }
+                    stdin.removeListener('data', onData);
+                    rl.close();
+                    reject(new Error('Cancelled by user'));
+                    return;
+                }
+                // Backspace/Delete
+                if (charStr === '\u007F' || charStr === '\b') {
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                    }
+                    return;
+                }
+                // Printable characters only
+                if (charStr >= ' ') {
+                    password += charStr;
+                }
+            };
+            stdin.on('data', onData);
+        });
+    }
+    /**
+     * Prompts user for username
+     */
+    async promptForUsername() {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve, reject) => {
+            rl.question('SEMP Username: ', (answer) => {
+                rl.close();
+                const username = answer.trim();
+                if (!username) {
+                    reject(new Error('Username cannot be empty'));
+                    return;
+                }
+                resolve(username);
+            });
+        });
+    }
+    /**
+     * Validates command inputs
+     */
+    validateInputs(flags) {
+        // Validate SEMP URL format
+        const sempUrl = flags['semp-url'];
+        if (!sempUrl.startsWith('http://') && !sempUrl.startsWith('https://')) {
+            this.error('SEMP URL must start with http:// or https://');
+        }
+        // Validate port range
+        const port = flags['semp-port'];
+        if (port < 1 || port > 65_535) {
+            this.error('SEMP port must be between 1 and 65535.');
+        }
+    }
+}

package/dist/commands/broker/login/cloud.d.ts

@@ -0,0 +1,56 @@
+import { type BrokerAuth, ScCommand } from '@dishantlangayan/sc-cli-core';
+export default class BrokerLoginCloud extends ScCommand<typeof BrokerLoginCloud> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'broker-name': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-prompt': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'org-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'set-default': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<BrokerAuth>;
+    /**
+     * Creates broker authentication configuration object
+     */
+    private createBrokerAuth;
+    /**
+     * Displays success message after login
+     */
+    private displaySuccessMessage;
+    /**
+     * Encodes username and password to base64 for basic authentication
+     */
+    private encodeBasicAuth;
+    /**
+     * Extract SEMP connection details from service response
+     */
+    private extractSempDetails;
+    /**
+     * Find service ID by broker name using Cloud API
+     * Uses RSQL filter: name==brokerName
+     */
+    private findServiceIdByName;
+    /**
+     * Get authenticated Cloud API connection
+     * Validates that user is logged in to Solace Cloud
+     */
+    private getCloudConnection;
+    /**
+     * Get detailed service information with expanded fields
+     */
+    private getServiceDetails;
+    /**
+     * Checks if broker exists and handles overwrite confirmation
+     * Same pattern as broker:login:basic
+     */
+    private handleExistingBroker;
+    /**
+     * Handles errors during login process
+     */
+    private handleLoginError;
+    /**
+     * Prompts user for confirmation with Y/n (default Yes)
+     */
+    private promptForConfirmation;
+}

package/dist/commands/broker/login/cloud.js

@@ -0,0 +1,333 @@
+import { AuthType, BrokerAuthError, BrokerAuthErrorCode, OrgError, OrgErrorCode, ScCommand, } from '@dishantlangayan/sc-cli-core';
+import { Flags } from '@oclif/core';
+import * as process from 'node:process';
+import * as readline from 'node:readline';
+export default class BrokerLoginCloud extends ScCommand {
+    static args = {};
+    static description = `Login to a Solace Cloud Event Broker using Cloud API credentials.
+
+Retrieves SEMP credentials automatically from Solace Cloud REST API.
+Requires prior authentication to Solace Cloud (org:login).
+
+The command will:
+1. Look up the broker by name in your Solace Cloud organization
+2. Retrieve SEMP endpoint details and credentials from Cloud API
+3. Store encrypted broker credentials locally for future use
+
+Required Cloud API permissions: Read access to Event Broker Services`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --broker-name=production-broker',
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --set-default',
+        '<%= config.bin %> <%= command.id %> --broker-name=staging-broker --org-name=my-org',
+        '<%= config.bin %> <%= command.id %> --broker-name=prod --no-prompt',
+    ];
+    static flags = {
+        'broker-name': Flags.string({
+            char: 'b',
+            description: 'Name of the broker in Solace Cloud',
+            required: true,
+        }),
+        'no-prompt': Flags.boolean({
+            default: false,
+            description: 'Skip confirmation prompts for overwriting existing broker',
+        }),
+        'org-name': Flags.string({
+            char: 'o',
+            description: 'Solace Cloud organization name (uses default org if not specified)',
+        }),
+        'set-default': Flags.boolean({
+            char: 'd',
+            default: false,
+            description: 'Set this broker as the default',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(BrokerLoginCloud);
+        try {
+            // Step 1: Get managers
+            const brokerAuthManager = await this.getBrokerAuthManager();
+            const orgManager = await this.getOrgManager();
+            // Step 2: Validate Cloud API authentication
+            const cloudConnection = await this.getCloudConnection(orgManager, flags['org-name']);
+            // Step 3: Handle existing broker
+            const brokerName = flags['broker-name'];
+            const isUpdate = await this.handleExistingBroker(brokerAuthManager, brokerName, flags['no-prompt']);
+            // Step 4: Fetch broker details from Cloud API
+            this.log(`Fetching broker details for '${brokerName}' from Solace Cloud...`);
+            const serviceId = await this.findServiceIdByName(cloudConnection, brokerName);
+            const serviceDetails = await this.getServiceDetails(cloudConnection, serviceId);
+            // Step 5: Extract SEMP credentials
+            const { msgVpnName, password, sempEndpoint, sempPort, username } = this.extractSempDetails(serviceDetails);
+            // Step 6: Create broker auth configuration
+            const accessToken = this.encodeBasicAuth(username, password);
+            const brokerAuth = this.createBrokerAuth({
+                accessToken,
+                brokerName,
+                msgVpnName,
+                sempEndpoint,
+                sempPort,
+            });
+            // Step 7: Store broker configuration
+            await (isUpdate ? brokerAuthManager.updateBroker(brokerName, brokerAuth) : brokerAuthManager.addBroker(brokerAuth));
+            // Step 8: Set as default if requested
+            if (flags['set-default']) {
+                await brokerAuthManager.setDefaultBroker(brokerName);
+            }
+            // Step 9: Display success message
+            this.displaySuccessMessage(isUpdate, brokerName, flags['set-default']);
+            return brokerAuth;
+        }
+        catch (error) {
+            this.handleLoginError(error, flags['broker-name']);
+        }
+    }
+    /**
+     * Creates broker authentication configuration object
+     */
+    createBrokerAuth(params) {
+        return {
+            accessToken: params.accessToken,
+            authType: AuthType.BASIC,
+            isSolaceCloud: true,
+            msgVpnName: params.msgVpnName,
+            name: params.brokerName,
+            sempEndpoint: params.sempEndpoint,
+            sempPort: params.sempPort,
+        };
+    }
+    /**
+     * Displays success message after login
+     */
+    displaySuccessMessage(isUpdate, brokerName, setDefault) {
+        const action = isUpdate ? 'updated' : 'logged in to';
+        this.log(`Successfully ${action} broker '${brokerName}'`);
+        if (setDefault) {
+            this.log('Set as default broker.');
+        }
+    }
+    /**
+     * Encodes username and password to base64 for basic authentication
+     */
+    encodeBasicAuth(username, password) {
+        const credentials = `${username}:${password}`;
+        return Buffer.from(credentials, 'utf8').toString('base64');
+    }
+    /**
+     * Extract SEMP connection details from service response
+     */
+    extractSempDetails(service) {
+        // Validate required fields
+        if (!service.msgVpnName) {
+            this.error('Missing msgVpnName in broker details.', { exit: 1 });
+        }
+        if (!service.defaultManagementHostname) {
+            this.error('Missing defaultManagementHostname in broker details.', { exit: 1 });
+        }
+        if (!service.serviceConnectionEndpoints || service.serviceConnectionEndpoints.length === 0) {
+            this.error('No service connection endpoints found for this broker.', { exit: 1 });
+        }
+        if (!service.broker?.msgVpns || service.broker.msgVpns.length === 0) {
+            this.error('Missing broker message VPN configuration.', { exit: 1 });
+        }
+        const msgVpn = service.broker.msgVpns[0];
+        if (!msgVpn.missionControlManagerLoginCredential) {
+            this.error('Missing SEMP credentials in broker details.', { exit: 1 });
+        }
+        // Find SEMP TLS port from all service connection endpoints
+        let sempPort;
+        for (const endpoint of service.serviceConnectionEndpoints) {
+            if (!endpoint.ports)
+                continue;
+            const sempPortConfig = endpoint.ports.find((p) => p.protocol === 'serviceManagementTlsListenPort');
+            if (sempPortConfig && sempPortConfig.port > 0) {
+                sempPort = sempPortConfig.port;
+                break;
+            }
+        }
+        if (!sempPort) {
+            this.error('SEMP TLS endpoint not found. Ensure the broker has SEMP over TLS enabled.', { exit: 1 });
+        }
+        // Extract credentials
+        const { password, username } = msgVpn.missionControlManagerLoginCredential;
+        if (!username || !password) {
+            this.error('Incomplete SEMP credentials in broker details.', { exit: 1 });
+        }
+        return {
+            msgVpnName: service.msgVpnName,
+            password,
+            sempEndpoint: `https://${service.defaultManagementHostname}`,
+            sempPort,
+            username,
+        };
+    }
+    /**
+     * Find service ID by broker name using Cloud API
+     * Uses RSQL filter: name==brokerName
+     */
+    async findServiceIdByName(cloudConnection, brokerName) {
+        try {
+            // Use customAttributes with RSQL filter to search by name
+            const endpoint = `/missionControl/eventBrokerServices?customAttributes=name==${brokerName}`;
+            const response = await cloudConnection.get(endpoint);
+            if (!response.data || response.data.length === 0) {
+                this.error(`Broker '${brokerName}' not found in Solace Cloud. Please check the broker name and try again.`, { exit: 1 });
+            }
+            if (response.data.length > 1) {
+                this.warn(`Multiple brokers found with name '${brokerName}'. Using the first match.`);
+            }
+            return response.data[0].id;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('401')) {
+                this.error('Cloud API authentication failed. Please run \'org:login\' again.', { exit: 1 });
+            }
+            if (error instanceof Error && error.message.includes('403')) {
+                this.error('Insufficient permissions to access broker information in Solace Cloud.', { exit: 1 });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get authenticated Cloud API connection
+     * Validates that user is logged in to Solace Cloud
+     */
+    async getCloudConnection(orgManager, orgName) {
+        try {
+            // If org-name provided, use that org; otherwise use default
+            const orgIdentifier = orgName ?? (await orgManager.getDefaultOrg())?.orgId;
+            if (!orgIdentifier) {
+                this.error('No Solace Cloud organization found. Please run \'org:login\' first to authenticate to Solace Cloud.', { exit: 1 });
+            }
+            // Create connection using org credentials
+            return await orgManager.createConnection(orgIdentifier);
+        }
+        catch (error) {
+            if (error instanceof OrgError) {
+                if (error.code === OrgErrorCode.NOT_INITIALIZED) {
+                    this.error('Solace Cloud authentication not initialized. Please run \'org:login\' first.', { exit: 1 });
+                }
+                if (error.code === OrgErrorCode.ORG_NOT_FOUND) {
+                    this.error(`Organization '${orgName}' not found. Please run 'org:login' first.`, { exit: 1 });
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get detailed service information with expanded fields
+     */
+    async getServiceDetails(cloudConnection, serviceId) {
+        try {
+            const endpoint = `/missionControl/eventBrokerServices/${serviceId}?expand=broker,serviceConnectionEndpoints`;
+            const response = await cloudConnection.get(endpoint);
+            if (!response.data) {
+                this.error('Failed to retrieve broker details from Solace Cloud.', { exit: 1 });
+            }
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404')) {
+                this.error('Broker not found in Solace Cloud.', { exit: 1 });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Checks if broker exists and handles overwrite confirmation
+     * Same pattern as broker:login:basic
+     */
+    async handleExistingBroker(brokerAuthManager, brokerName, noPrompt) {
+        const exists = await brokerAuthManager.brokerExists(brokerName);
+        if (!exists) {
+            return false;
+        }
+        // If no-prompt, assume yes to overwrite
+        if (noPrompt) {
+            return true;
+        }
+        const shouldOverwrite = await this.promptForConfirmation(`Broker '${brokerName}' already exists. Do you want to overwrite the credentials?`);
+        if (!shouldOverwrite) {
+            this.log('Login cancelled.');
+            this.exit(0);
+        }
+        return true;
+    }
+    /**
+     * Handles errors during login process
+     */
+    handleLoginError(error, brokerName) {
+        if (error instanceof BrokerAuthError) {
+            switch (error.code) {
+                case BrokerAuthErrorCode.FILE_WRITE_ERROR: {
+                    this.error('Failed to save broker configuration. Please check file permissions.');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_ACCESS_TOKEN: {
+                    this.error('Failed to encode credentials.');
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_ENDPOINT: {
+                    this.error('Invalid SEMP endpoint URL format.');
+                    break;
+                }
+                default: {
+                    this.error(`Login failed: ${error.message}`);
+                    break;
+                }
+            }
+        }
+        if (error instanceof OrgError) {
+            switch (error.code) {
+                case OrgErrorCode.INVALID_ACCESS_TOKEN: {
+                    this.error('Cloud API token expired or invalid. Please run \'org:login\' again.');
+                    break;
+                }
+                case OrgErrorCode.NOT_INITIALIZED: {
+                    this.error('Solace Cloud authentication not initialized. Please run \'org:login\' first.');
+                    break;
+                }
+                case OrgErrorCode.ORG_NOT_FOUND: {
+                    this.error('Solace Cloud organization not found. Please run \'org:login\' first.');
+                    break;
+                }
+                default: {
+                    this.error(`Cloud API error: ${error.message}`);
+                    break;
+                }
+            }
+        }
+        if (error instanceof Error) {
+            // Check for network errors
+            if (error.message.includes('ENOTFOUND') || error.message.includes('ECONNREFUSED')) {
+                this.error('Failed to connect to Solace Cloud API. Please check your network connection.');
+            }
+            // Check for Cloud API errors
+            if (error.message.includes('404')) {
+                this.error(`Broker '${brokerName}' not found in Solace Cloud.`);
+            }
+            if (error.message.includes('401') || error.message.includes('403')) {
+                this.error('Cloud API authentication failed. Please run \'org:login\' again.');
+            }
+        }
+        // Re-throw unexpected errors
+        throw error;
+    }
+    /**
+     * Prompts user for confirmation with Y/n (default Yes)
+     */
+    async promptForConfirmation(message) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${message} (Y/n): `, (answer) => {
+                rl.close();
+                const normalized = answer.trim().toLowerCase();
+                // Default to yes if empty, accept y/yes as confirmation
+                const confirmed = normalized === '' || normalized === 'y' || normalized === 'yes';
+                resolve(confirmed);
+            });
+        });
+    }
+}

package/dist/commands/broker/login/list.d.ts

@@ -0,0 +1,10 @@
+import { BrokerAuth, ScCommand } from '@dishantlangayan/sc-cli-core';
+export default class BrokerLoginList extends ScCommand<typeof BrokerLoginList> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<{
+        data: BrokerAuth[];
+    }>;
+}