@dishantlangayan/sc-plugin-broker 0.1.0

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

@@ -0,0 +1,36 @@
+import { renderTable, ScCommand } from '@dishantlangayan/sc-cli-core';
+export default class BrokerLoginList extends ScCommand {
+    static args = {};
+    static description = `List all authenticated brokers.
+
+Displays brokers you have logged into, including their authentication type, SEMP endpoints, and which one is set as default.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {};
+    async run() {
+        const brokerAuthManager = await this.getBrokerAuthManager();
+        // Get all authenticated brokers
+        const allBrokers = await brokerAuthManager.getAllBrokers();
+        // Handle case when no brokers exist
+        if (allBrokers.length === 0) {
+            this.log("No brokers found. Run 'sc broker:login:basic' to authenticate.");
+            return { data: [] };
+        }
+        // Create table array (first row is headers, rest are data rows)
+        const brokerArray = [
+            ['Broker Name', 'Auth Type', 'SEMP Endpoint', 'SEMP Port', 'Is Default'],
+            ...allBrokers.map((broker) => [
+                broker.name,
+                String(broker.authType),
+                broker.sempEndpoint,
+                broker.sempPort.toString(),
+                broker.isDefault ? 'Yes' : '',
+            ]),
+        ];
+        // Display results as a table
+        this.log(renderTable(brokerArray));
+        // Return raw data for --json flag support
+        return { data: allBrokers };
+    }
+}

package/dist/commands/broker/logout.d.ts

@@ -0,0 +1,15 @@
+import { ScCommand } from '@dishantlangayan/sc-cli-core';
+export default class BrokerLogout extends ScCommand<typeof BrokerLogout> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'broker-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-prompt': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<{
+        count: number;
+        loggedOut: string[];
+    }>;
+}

package/dist/commands/broker/logout.js

@@ -0,0 +1,111 @@
+import { ScCommand } from '@dishantlangayan/sc-cli-core';
+import { checkbox, confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+export default class BrokerLogout extends ScCommand {
+    static args = {};
+    static description = `Logout from authenticated brokers.
+
+Removes locally stored broker credentials.
+Interactive mode allows selection with arrow keys and spacebar.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --broker-name=prod --no-prompt',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Logout from all brokers',
+            exclusive: ['broker-name'],
+        }),
+        'broker-name': Flags.string({
+            char: 'b',
+            description: 'Broker name to logout from',
+            exclusive: ['all'],
+        }),
+        'no-prompt': Flags.boolean({
+            default: false,
+            description: 'Skip confirmation prompt and assume Yes',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(BrokerLogout);
+        const brokerName = flags['broker-name'];
+        // Get BrokerAuthManager instance
+        const brokerAuthManager = await this.getBrokerAuthManager();
+        // Get all authenticated brokers
+        const allBrokers = await brokerAuthManager.getAllBrokers();
+        // Handle case when no brokers exist
+        if (allBrokers.length === 0) {
+            this.log("No brokers found. Run 'sc broker:login:basic' to authenticate.");
+            return { count: 0, loggedOut: [] };
+        }
+        // Determine which brokers to logout
+        let brokerNamesToLogout = [];
+        if (flags.all) {
+            // Logout from all brokers
+            brokerNamesToLogout = allBrokers.map((broker) => broker.name);
+        }
+        else if (brokerName) {
+            // Logout from specific broker
+            const broker = allBrokers.find((b) => b.name === brokerName);
+            if (!broker) {
+                this.error(`Broker '${brokerName}' not found. Run 'sc broker:login:list' to see available brokers.`, { exit: 2 });
+            }
+            brokerNamesToLogout = [broker.name];
+        }
+        else {
+            // Interactive mode: let user select brokers
+            try {
+                brokerNamesToLogout = await checkbox({
+                    choices: allBrokers.map((broker) => ({
+                        name: broker.isDefault ? `${broker.name} (default)` : broker.name,
+                        value: broker.name,
+                    })),
+                    message: 'Select brokers to logout from:',
+                    required: true,
+                });
+            }
+            catch {
+                // User cancelled the selection (Ctrl+C)
+                this.log('Logout cancelled.');
+                return { count: 0, loggedOut: [] };
+            }
+        }
+        // Confirm logout unless --no-prompt flag is set
+        if (!flags['no-prompt']) {
+            const count = brokerNamesToLogout.length;
+            const brokerWord = count === 1 ? 'broker' : 'brokers';
+            try {
+                const shouldProceed = await confirm({
+                    default: true,
+                    message: `Are you sure you want to logout from ${count} ${brokerWord}?`,
+                });
+                if (!shouldProceed) {
+                    this.log('Logout cancelled.');
+                    return { count: 0, loggedOut: [] };
+                }
+            }
+            catch {
+                // User cancelled the confirmation (Ctrl+C)
+                this.log('Logout cancelled.');
+                return { count: 0, loggedOut: [] };
+            }
+        }
+        // Logout from selected brokers (remove all in parallel)
+        await Promise.all(brokerNamesToLogout.map((name) => brokerAuthManager.removeBroker(name)));
+        // Display success messages
+        for (const name of brokerNamesToLogout) {
+            const broker = allBrokers.find((b) => b.name === name);
+            const displayName = broker?.isDefault ? `${name} (default)` : name;
+            this.log(`Successfully logged out from: ${displayName}`);
+        }
+        // Return result for --json support
+        return {
+            count: brokerNamesToLogout.length,
+            loggedOut: brokerNamesToLogout,
+        };
+    }
+}

package/dist/commands/broker/queue/create.d.ts

@@ -0,0 +1,28 @@
+import { ScCommand } from '@dishantlangayan/sc-cli-core';
+import { MsgVpnQueueCreateResponse } from '../../../types/msgvpn-queue.js';
+export default class BrokerQueueCreate extends ScCommand<typeof BrokerQueueCreate> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'access-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'broker-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'broker-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dead-msg-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'egress-enabled': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'ingress-enabled': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'max-msg-spool-usage': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-redelivery-count': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-ttl': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'msg-vpn-name': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        owner: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        permission: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'queue-name': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'respect-ttl-enabled': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<MsgVpnQueueCreateResponse>;
+    /**
+     * Builds the queue creation request body from command flags
+     */
+    private buildQueueRequest;
+}

package/dist/commands/broker/queue/create.js

@@ -0,0 +1,116 @@
+import { printObjectAsKeyValueTable, ScCommand } from '@dishantlangayan/sc-cli-core';
+import { Flags } from '@oclif/core';
+import { resolveBrokerConnection } from '../../../lib/broker-utils.js';
+export default class BrokerQueueCreate extends ScCommand {
+    static args = {};
+    static description = `Create a Queue on a Solace Event Broker.
+
+Any attribute missing from the request will be set to its default value. The creation of instances of this object are synchronized to HA mates and replication sites via config-sync.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --queue-name=myQueue --msg-vpn-name=default',
+        '<%= config.bin %> <%= command.id %> --broker-id=dev-broker --queue-name=myQueue --msg-vpn-name=default --access-type=non-exclusive',
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --queue-name=myQueue --msg-vpn-name=default --owner=user1 --permission=consume',
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --queue-name=myQueue --msg-vpn-name=default --max-msg-spool-usage=1024 --egress-enabled --ingress-enabled',
+        '<%= config.bin %> <%= command.id %> --broker-name=dev-broker --queue-name=myQueue --msg-vpn-name=default --dead-msg-queue=#DEAD_MSG_QUEUE --max-redelivery-count=3',
+    ];
+    static flags = {
+        'access-type': Flags.string({
+            char: 'a',
+            description: 'The access type for the queue.',
+            options: ['exclusive', 'non-exclusive'],
+        }),
+        'broker-id': Flags.string({
+            char: 'b',
+            description: 'Stored broker identifier.',
+            exactlyOne: ['broker-id', 'broker-name'],
+        }),
+        'broker-name': Flags.string({
+            char: 'n',
+            description: 'Stored broker name.',
+            exactlyOne: ['broker-id', 'broker-name'],
+        }),
+        'dead-msg-queue': Flags.string({
+            description: 'The name of the Dead Message Queue.',
+        }),
+        'egress-enabled': Flags.boolean({
+            allowNo: true,
+            description: 'Enable or disable egress (message consumption) from the queue.',
+        }),
+        'ingress-enabled': Flags.boolean({
+            allowNo: true,
+            description: 'Enable or disable ingress (message reception) to the queue.',
+        }),
+        'max-msg-spool-usage': Flags.integer({
+            char: 's',
+            description: 'The maximum message spool usage allowed by the queue, in megabytes (MB).',
+            min: 0,
+        }),
+        'max-redelivery-count': Flags.integer({
+            description: 'The maximum number of times a message will be redelivered before it is discarded or moved to the DMQ.',
+            min: 0,
+        }),
+        'max-ttl': Flags.integer({
+            description: 'The maximum time in seconds a message can stay in the queue when respect-ttl-enabled is true.',
+            min: 0,
+        }),
+        'msg-vpn-name': Flags.string({
+            char: 'v',
+            description: 'The name of the Message VPN.',
+            required: true,
+        }),
+        owner: Flags.string({
+            char: 'o',
+            description: 'The client username that owns the queue and has permission equivalent to delete.',
+        }),
+        permission: Flags.string({
+            char: 'p',
+            default: 'consume',
+            description: 'The permission level for all consumers of the queue, excluding the owner.',
+            options: ['consume', 'delete', 'modify-topic', 'no-access', 'read-only'],
+        }),
+        'queue-name': Flags.string({
+            char: 'q',
+            description: 'The name of the queue to create.',
+            required: true,
+        }),
+        'respect-ttl-enabled': Flags.boolean({
+            allowNo: true,
+            description: 'Enable or disable the respecting of the time-to-live (TTL) for messages.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(BrokerQueueCreate);
+        // Resolve broker identifier (broker-id OR broker-name are aliases)
+        const brokerIdentifier = flags['broker-id'] ?? flags['broker-name'] ?? '';
+        // Create SEMP connection using stored credentials
+        const sempConn = await resolveBrokerConnection(this, brokerIdentifier);
+        // Build queue creation request body
+        const queueBody = this.buildQueueRequest(flags);
+        // Make SEMP Config API call to create the queue
+        const endpoint = `/SEMP/v2/config/msgVpns/${flags['msg-vpn-name']}/queues`;
+        const sempResp = await sempConn.post(endpoint, queueBody);
+        // Display results
+        this.log(printObjectAsKeyValueTable(sempResp.data));
+        return sempResp;
+    }
+    /**
+     * Builds the queue creation request body from command flags
+     */
+    buildQueueRequest(flags) {
+        return {
+            queueName: flags['queue-name'],
+            ...(flags['access-type'] && { accessType: flags['access-type'] }),
+            ...(flags['dead-msg-queue'] && { deadMsgQueue: flags['dead-msg-queue'] }),
+            ...(flags['egress-enabled'] !== undefined && { egressEnabled: flags['egress-enabled'] }),
+            ...(flags['ingress-enabled'] !== undefined && { ingressEnabled: flags['ingress-enabled'] }),
+            ...(flags['max-msg-spool-usage'] !== undefined && { maxMsgSpoolUsage: flags['max-msg-spool-usage'] }),
+            ...(flags['max-redelivery-count'] !== undefined && { maxRedeliveryCount: flags['max-redelivery-count'] }),
+            ...(flags['max-ttl'] !== undefined && { maxTtl: flags['max-ttl'] }),
+            ...(flags.owner && { owner: flags.owner }),
+            ...(flags.permission && {
+                permission: flags.permission,
+            }),
+            ...(flags['respect-ttl-enabled'] !== undefined && { respectTtlEnabled: flags['respect-ttl-enabled'] }),
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/broker-utils.d.ts

@@ -0,0 +1,25 @@
+import { ScCommand, ScConnection } from '@dishantlangayan/sc-cli-core';
+import { Command } from '@oclif/core';
+/**
+ * Resolves broker and creates authenticated SEMP connection
+ *
+ * This utility function handles the common pattern of resolving which broker
+ * to use for SEMP API calls. It validates the broker identifier exists in
+ * stored credentials and creates an authenticated connection.
+ *
+ * @param command - The ScCommand instance (for error handling and BrokerAuthManager access)
+ * @param brokerIdentifier - Broker ID or name from --broker-id or --broker-name flag
+ * @param timeout - Optional timeout override in milliseconds
+ * @returns Configured ScConnection instance ready for SEMP API calls
+ * @throws Will call command.error() with user-friendly messages for various error scenarios
+ *
+ * @example
+ * ```typescript
+ * // In a command's run() method:
+ * const {flags} = await this.parse(MyCommand)
+ * const brokerIdentifier = flags['broker-id'] ?? flags['broker-name'] ?? ''
+ * const sempConn = await resolveBrokerConnection(this, brokerIdentifier)
+ * const resp = await sempConn.get('/SEMP/v2/config/msgVpns')
+ * ```
+ */
+export declare function resolveBrokerConnection(command: ScCommand<typeof Command>, brokerIdentifier: string, timeout?: number): Promise<ScConnection>;

package/dist/lib/broker-utils.js

@@ -0,0 +1,62 @@
+import { BrokerAuthError, BrokerAuthErrorCode } from '@dishantlangayan/sc-cli-core';
+/**
+ * Resolves broker and creates authenticated SEMP connection
+ *
+ * This utility function handles the common pattern of resolving which broker
+ * to use for SEMP API calls. It validates the broker identifier exists in
+ * stored credentials and creates an authenticated connection.
+ *
+ * @param command - The ScCommand instance (for error handling and BrokerAuthManager access)
+ * @param brokerIdentifier - Broker ID or name from --broker-id or --broker-name flag
+ * @param timeout - Optional timeout override in milliseconds
+ * @returns Configured ScConnection instance ready for SEMP API calls
+ * @throws Will call command.error() with user-friendly messages for various error scenarios
+ *
+ * @example
+ * ```typescript
+ * // In a command's run() method:
+ * const {flags} = await this.parse(MyCommand)
+ * const brokerIdentifier = flags['broker-id'] ?? flags['broker-name'] ?? ''
+ * const sempConn = await resolveBrokerConnection(this, brokerIdentifier)
+ * const resp = await sempConn.get('/SEMP/v2/config/msgVpns')
+ * ```
+ */
+export async function resolveBrokerConnection(command, brokerIdentifier, timeout) {
+    try {
+        // Use type assertion to access protected method
+        const brokerAuthManager = await command.getBrokerAuthManager();
+        // Validate broker exists in stored credentials
+        try {
+            await brokerAuthManager.getBroker(brokerIdentifier);
+        }
+        catch (error) {
+            if (error instanceof BrokerAuthError && error.code === BrokerAuthErrorCode.BROKER_NOT_FOUND) {
+                command.error(`Broker '${brokerIdentifier}' not found. Please run 'broker:login:basic' to store broker credentials first.`, { exit: 2 });
+            }
+            throw error;
+        }
+        // Create SEMP connection using stored credentials
+        return await brokerAuthManager.createConnection(brokerIdentifier, timeout);
+    }
+    catch (error) {
+        // Handle BrokerAuthManager-specific errors
+        if (error instanceof BrokerAuthError) {
+            switch (error.code) {
+                case BrokerAuthErrorCode.BROKER_NOT_FOUND: {
+                    command.error(`Broker '${brokerIdentifier}' not found. Please run 'broker:login:basic' to store broker credentials first.`, { exit: 2 });
+                    break;
+                }
+                case BrokerAuthErrorCode.INVALID_ACCESS_TOKEN: {
+                    command.error(`Invalid or expired credentials for broker '${brokerIdentifier}'. Please run 'broker:login:basic' again.`, { exit: 2 });
+                    break;
+                }
+                default: {
+                    command.error(`Broker authentication failed: ${error.message}`, { exit: 2 });
+                    break;
+                }
+            }
+        }
+        // Re-throw unexpected errors
+        throw error;
+    }
+}

package/dist/types/cloud-api.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Cloud API Type Definitions
+ * Based on https://api.solace.dev/cloud/openapi/63dc1facc5b9980042ed3901
+ */
+/**
+ * Port configuration for a service connection endpoint
+ */
+export interface Port {
+    port: number;
+    protocol: string;
+}
+/**
+ * Service connection endpoint
+ */
+export interface ServiceConnectionEndpoint {
+    accessType?: string;
+    creationState?: string;
+    description?: string;
+    hostNames?: string[];
+    id: string;
+    k8sServiceId?: string;
+    k8sServiceType?: string;
+    name: string;
+    ports: Port[];
+    type?: string;
+}
+/**
+ * Mission Control Manager credentials for SEMP access
+ */
+export interface MissionControlManagerCredential {
+    password: string;
+    token?: string;
+    username: string;
+}
+/**
+ * Message VPN configuration
+ */
+export interface MsgVpn {
+    managementAdminLoginCredential?: MissionControlManagerCredential;
+    missionControlManagerLoginCredential: MissionControlManagerCredential;
+    msgVpnName: string;
+    serviceLoginCredential?: {
+        password: string;
+        username: string;
+    };
+}
+/**
+ * Broker configuration
+ */
+export interface Broker {
+    cluster?: {
+        name: string;
+        password: string;
+        primaryRouterName: string;
+        remoteAddress: string;
+        supportedAuthenticationMode?: string[];
+    };
+    managementReadOnlyLoginCredential?: MissionControlManagerCredential;
+    msgVpns?: MsgVpn[];
+    version?: string;
+}
+/**
+ * Event Broker Service response from Cloud API
+ */
+export interface EventBrokerService {
+    adminState?: string;
+    broker?: Broker;
+    createdTime?: string;
+    creationState?: string;
+    datacenterId?: string;
+    defaultManagementHostname: string;
+    environmentId?: string;
+    eventBrokerServiceVersion?: string;
+    id: string;
+    msgVpnName: string;
+    name: string;
+    ownedBy?: string;
+    serviceClassId?: string;
+    serviceConnectionEndpoints?: ServiceConnectionEndpoint[];
+    type?: string;
+}
+/**
+ * List services response
+ */
+export interface ListServicesResponse {
+    data: EventBrokerService[];
+    meta?: {
+        pagination?: {
+            count: number;
+            pageNumber: number;
+            pageSize: number;
+            totalCount: number;
+            totalPages: number;
+        };
+    };
+}
+/**
+ * Get service details response
+ */
+export interface GetServiceResponse {
+    data: EventBrokerService;
+}

package/dist/types/cloud-api.js

@@ -0,0 +1,5 @@
+/**
+ * Cloud API Type Definitions
+ * Based on https://api.solace.dev/cloud/openapi/63dc1facc5b9980042ed3901
+ */
+export {};

package/dist/types/msgvpn-queue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SEMP Config API type definitions for MsgVpnQueue operations
+ */
+/**
+ * Request body for creating a queue via SEMP Config API
+ */
+export interface MsgVpnQueueCreateRequest {
+    accessType?: 'exclusive' | 'non-exclusive';
+    deadMsgQueue?: string;
+    egressEnabled?: boolean;
+    ingressEnabled?: boolean;
+    maxMsgSpoolUsage?: number;
+    maxRedeliveryCount?: number;
+    maxTtl?: number;
+    owner?: string;
+    permission?: 'consume' | 'delete' | 'modify-topic' | 'no-access' | 'read-only';
+    queueName: string;
+    respectTtlEnabled?: boolean;
+}
+/**
+ * Response from SEMP Config API queue creation
+ */
+export interface MsgVpnQueueCreateResponse {
+    data: MsgVpnQueue;
+    links?: {
+        [key: string]: unknown;
+        uri?: string;
+    };
+    meta: SempMeta;
+}
+/**
+ * MsgVpnQueue object returned by SEMP
+ */
+export interface MsgVpnQueue {
+    [key: string]: unknown;
+    msgVpnName: string;
+    queueName: string;
+}
+/**
+ * SEMP response metadata
+ */
+export interface SempMeta {
+    [key: string]: unknown;
+    request?: {
+        method?: string;
+        uri?: string;
+    };
+    responseCode?: number;
+}

package/dist/types/msgvpn-queue.js

@@ -0,0 +1,4 @@
+/**
+ * SEMP Config API type definitions for MsgVpnQueue operations
+ */
+export {};