@dishantlangayan/sc-cli-core 0.4.0 → 0.5.1

package/README.md

@@ -23,6 +23,8 @@ The ScConnection class provide abstraction functions for Solace Cloud API REST c
 ## OrgManager
 The OrgManager class provides utility functions to store and retrieve Solace Cloud authentication information from user's home directory: `~/.sc/` or `%USERPROFILE%\sc\`. The implementation uses AES-256-GCM for authenticated encryption and provides machine-bound encryption that combines OS-level security (keychain) with machine-specific identifiers, making credentials non-transferable between machines.
 
+Supports changing of the Solace Cloud REST API base url using the environment variable `SC_BASE_URL` and API version using `SC_API_VERSION`.
+
 ## BrokerAuthManager
 The BrokerAuthManager class provides utility functions to store and retrieve broker SEMP management authentication information similar to the `OrgManager` class. It supports Basic and OAuth authentication schemes.
 

package/lib/auth/auth-manager.js

@@ -85,8 +85,11 @@ export class BrokerAuthManager {
         }
         const baseURL = `${broker.sempEndpoint}:${broker.sempPort}`;
         const accessToken = broker.authType === AuthType.OAUTH ? broker.accessToken : broker.encodedCredentials;
-        const isBasic = broker.authType === AuthType.BASIC;
-        return new ScConnection(baseURL, accessToken, timeout, isBasic);
+        return new ScConnection(baseURL, accessToken, {
+            apiType: 'semp',
+            authType: broker.authType === AuthType.BASIC ? 'basic' : 'bearer',
+            timeout,
+        });
     }
     /**
      * Get all broker configurations

package/lib/auth/index.d.ts

@@ -1,7 +1,9 @@
 /**
- * Broker authentication management module
- * Provides encrypted storage for SEMP broker credentials
+ * Authentication management module
+ * Provides encrypted storage for broker and organization credentials
  */
 export { BrokerAuthEncryption } from './auth-encryption.js';
 export { BrokerAuthManager } from './auth-manager.js';
 export { AuthType, type BasicBrokerAuth, type BrokerAuth, type BrokerAuthBase, BrokerAuthError, BrokerAuthErrorCode, type BrokerAuthStorage, type EncryptedData, type EncryptionMetadata, type OAuthBrokerAuth, } from './auth-types.js';
+export { OrgManager } from './org-manager.js';
+export { type OrgConfig, OrgError, OrgErrorCode, type OrgStorage } from './org-types.js';

package/lib/auth/index.js

@@ -1,7 +1,9 @@
 /**
- * Broker authentication management module
- * Provides encrypted storage for SEMP broker credentials
+ * Authentication management module
+ * Provides encrypted storage for broker and organization credentials
  */
 export { BrokerAuthEncryption } from './auth-encryption.js';
 export { BrokerAuthManager } from './auth-manager.js';
 export { AuthType, BrokerAuthError, BrokerAuthErrorCode, } from './auth-types.js';
+export { OrgManager } from './org-manager.js';
+export { OrgError, OrgErrorCode } from './org-types.js';

package/lib/auth/org-manager.d.ts

@@ -1,3 +1,4 @@
+import { ScConnection } from '../util/sc-connection.js';
 import { KeychainService } from './keychain.js';
 import { type OrgConfig } from './org-types.js';
 /**
@@ -28,6 +29,13 @@ export declare class OrgManager {
      * Clear all organization configurations
      */
     clearAll(): Promise<void>;
+    /**
+     * Create ScConnection instance from stored org config
+     * @param identifier - Organization ID or alias
+     * @param timeout - Optional timeout override (default: 10000ms)
+     * @returns Configured ScConnection instance
+     */
+    createConnection(identifier: string, timeout?: number): Promise<ScConnection>;
     /**
      * Get all organization configurations
      * @returns Array of all organization configurations

package/lib/auth/org-manager.js

@@ -1,6 +1,8 @@
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { DefaultBaseUrl, EnvironmentVariable, envVars } from '../config/env-vars.js';
+import { ScConnection } from '../util/sc-connection.js';
 import { BrokerAuthEncryption } from './auth-encryption.js';
 import { KeychainService } from './keychain.js';
 import { OrgError, OrgErrorCode } from './org-types.js';
@@ -71,6 +73,29 @@ export class OrgManager {
         this.storage.orgs = [];
         await this.saveStorage();
     }
+    /**
+     * Create ScConnection instance from stored org config
+     * @param identifier - Organization ID or alias
+     * @param timeout - Optional timeout override (default: 10000ms)
+     * @returns Configured ScConnection instance
+     */
+    async createConnection(identifier, timeout = 10_000) {
+        this.ensureInitialized();
+        const org = await this.getOrg(identifier);
+        if (!org) {
+            throw new OrgError(`Organization '${identifier}' not found`, OrgErrorCode.ORG_NOT_FOUND);
+        }
+        // Get base URL: org config → env var → default
+        const baseURL = org.baseUrl ?? envVars.getString(EnvironmentVariable.SC_BASE_URL, DefaultBaseUrl);
+        // Get API version: org config → env var → default 'v2'
+        const apiVersion = org.apiVersion ?? envVars.getString(EnvironmentVariable.SC_API_VERSION, 'v2');
+        return new ScConnection(baseURL, org.accessToken, {
+            apiType: 'cloud',
+            apiVersion,
+            authType: 'bearer',
+            timeout,
+        });
+    }
     /**
      * Get all organization configurations
      * @returns Array of all organization configurations
@@ -332,5 +357,24 @@ export class OrgManager {
         if (org.alias !== undefined && org.alias.trim() === '') {
             throw new OrgError('Alias cannot be empty if provided', OrgErrorCode.INVALID_ORG_ID);
         }
+        // Validate apiVersion if provided
+        if (org.apiVersion !== undefined && org.apiVersion.trim() === '') {
+            throw new OrgError('API version cannot be empty if provided', OrgErrorCode.INVALID_API_VERSION);
+        }
+        // Validate baseUrl if provided
+        if (org.baseUrl !== undefined) {
+            // Must not be empty or whitespace
+            if (org.baseUrl.trim() === '') {
+                throw new OrgError('Base URL cannot be empty if provided', OrgErrorCode.INVALID_BASE_URL);
+            }
+            // Must start with http:// or https://
+            if (!(org.baseUrl.startsWith('http://') || org.baseUrl.startsWith('https://'))) {
+                throw new OrgError('Base URL must start with http:// or https://', OrgErrorCode.INVALID_BASE_URL);
+            }
+            // Should not end with trailing slash
+            if (org.baseUrl.endsWith('/')) {
+                throw new OrgError('Base URL should not end with a slash', OrgErrorCode.INVALID_BASE_URL);
+            }
+        }
     }
 }

package/lib/auth/org-types.d.ts

@@ -4,6 +4,8 @@
 export interface OrgConfig {
     accessToken: string;
     alias?: string;
+    apiVersion?: string;
+    baseUrl?: string;
     isDefault?: boolean;
     orgId: string;
 }
@@ -23,6 +25,8 @@ export declare enum OrgErrorCode {
     FILE_READ_ERROR = "FILE_READ_ERROR",
     FILE_WRITE_ERROR = "FILE_WRITE_ERROR",
     INVALID_ACCESS_TOKEN = "INVALID_ACCESS_TOKEN",
+    INVALID_API_VERSION = "INVALID_API_VERSION",
+    INVALID_BASE_URL = "INVALID_BASE_URL",
     INVALID_ORG_ID = "INVALID_ORG_ID",
     NOT_INITIALIZED = "NOT_INITIALIZED",
     ORG_ALREADY_EXISTS = "ORG_ALREADY_EXISTS",

package/lib/auth/org-types.js

@@ -8,6 +8,8 @@ export var OrgErrorCode;
     OrgErrorCode["FILE_READ_ERROR"] = "FILE_READ_ERROR";
     OrgErrorCode["FILE_WRITE_ERROR"] = "FILE_WRITE_ERROR";
     OrgErrorCode["INVALID_ACCESS_TOKEN"] = "INVALID_ACCESS_TOKEN";
+    OrgErrorCode["INVALID_API_VERSION"] = "INVALID_API_VERSION";
+    OrgErrorCode["INVALID_BASE_URL"] = "INVALID_BASE_URL";
     OrgErrorCode["INVALID_ORG_ID"] = "INVALID_ORG_ID";
     OrgErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
     OrgErrorCode["ORG_ALREADY_EXISTS"] = "ORG_ALREADY_EXISTS";

package/lib/config/env-vars.d.ts

@@ -1,8 +1,7 @@
 export declare enum EnvironmentVariable {
     'SC_ACCESS_TOKEN' = "SC_ACCESS_TOKEN",
     'SC_API_VERSION' = "SC_API_VERSION",
-    'SC_BASE_URL' = "SC_BASE_URL",
-    'SEMP_API_VERSION' = "SEMP_API_VERSION"
+    'SC_BASE_URL' = "SC_BASE_URL"
 }
 export declare const DefaultBaseUrl = "https://api.solace.cloud";
 /**

package/lib/config/env-vars.js

@@ -3,7 +3,6 @@ export var EnvironmentVariable;
     EnvironmentVariable["SC_ACCESS_TOKEN"] = "SC_ACCESS_TOKEN";
     EnvironmentVariable["SC_API_VERSION"] = "SC_API_VERSION";
     EnvironmentVariable["SC_BASE_URL"] = "SC_BASE_URL";
-    EnvironmentVariable["SEMP_API_VERSION"] = "SEMP_API_VERSION";
 })(EnvironmentVariable || (EnvironmentVariable = {}));
 export const DefaultBaseUrl = 'https://api.solace.cloud';
 /**

package/lib/exported.d.ts

@@ -1,6 +1,6 @@
-export { AuthType, type BasicBrokerAuth, type BrokerAuth, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, type OAuthBrokerAuth, } from './auth/index.js';
+export { AuthType, type BasicBrokerAuth, type BrokerAuth, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, type OAuthBrokerAuth, type OrgConfig, OrgError, OrgErrorCode, OrgManager, type OrgStorage, } from './auth/index.js';
 export { EnvironmentVariable, envVars } from './config/env-vars.js';
 export { ScCommand } from './sc-command.js';
-export { ScConnection } from './util/sc-connection.js';
+export { type ApiType, type HttpAuthType, ScConnection, type ScConnectionOptions } from './util/sc-connection.js';
 export { sleep } from './util/util.js';
 export * from './ux/table.js';

package/lib/exported.js

@@ -1,4 +1,4 @@
-export { AuthType, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, } from './auth/index.js';
+export { AuthType, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, OrgError, OrgErrorCode, OrgManager, } from './auth/index.js';
 export { EnvironmentVariable, envVars } from './config/env-vars.js';
 export { ScCommand } from './sc-command.js';
 export { ScConnection } from './util/sc-connection.js';

package/lib/sc-command.d.ts

@@ -1,4 +1,6 @@
 import { Command, Interfaces } from '@oclif/core';
+import { BrokerAuthManager } from './auth/auth-manager.js';
+import { OrgManager } from './auth/org-manager.js';
 export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof ScCommand)['baseFlags'] & T['flags']>;
 export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
 /**
@@ -14,9 +16,21 @@ export declare abstract class ScCommand<T extends typeof Command> extends Comman
     static enableJsonFlag: boolean;
     protected args: Args<T>;
     protected flags: Flags<T>;
+    private _brokerAuthManager?;
+    private _orgManager?;
     protected catch(err: Error & {
         exitCode?: number;
     }): Promise<unknown>;
     protected finally(_: Error | undefined): Promise<unknown>;
+    /**
+     * Get BrokerAuthManager instance with lazy initialization
+     * @returns Initialized BrokerAuthManager instance
+     */
+    protected getBrokerAuthManager(): Promise<BrokerAuthManager>;
+    /**
+     * Get OrgManager instance with lazy initialization
+     * @returns Initialized OrgManager instance
+     */
+    protected getOrgManager(): Promise<OrgManager>;
     init(): Promise<void>;
 }

package/lib/sc-command.js

@@ -1,5 +1,6 @@
 import { Command, Flags } from '@oclif/core';
-import { DefaultBaseUrl, EnvironmentVariable, envVars } from './config/env-vars.js';
+import { BrokerAuthManager } from './auth/auth-manager.js';
+import { OrgManager } from './auth/org-manager.js';
 /**
  * A base command that provided common functionality for all sc commands.
  *
@@ -20,6 +21,8 @@ export class ScCommand extends Command {
     static enableJsonFlag = true;
     args;
     flags;
+    _brokerAuthManager;
+    _orgManager;
     async catch(err) {
         // add any custom logic to handle errors from the command
         // or simply return the parent class error handling
@@ -29,6 +32,28 @@ export class ScCommand extends Command {
         // called after run and catch regardless of whether or not the command errored
         return super.finally(_);
     }
+    /**
+     * Get BrokerAuthManager instance with lazy initialization
+     * @returns Initialized BrokerAuthManager instance
+     */
+    async getBrokerAuthManager() {
+        if (!this._brokerAuthManager) {
+            this._brokerAuthManager = BrokerAuthManager.getInstance();
+            await this._brokerAuthManager.initialize();
+        }
+        return this._brokerAuthManager;
+    }
+    /**
+     * Get OrgManager instance with lazy initialization
+     * @returns Initialized OrgManager instance
+     */
+    async getOrgManager() {
+        if (!this._orgManager) {
+            this._orgManager = OrgManager.getInstance();
+            await this._orgManager.initialize();
+        }
+        return this._orgManager;
+    }
     async init() {
         await super.init();
         const { args, flags } = await this.parse({
@@ -40,15 +65,5 @@ export class ScCommand extends Command {
         });
         this.flags = flags;
         this.args = args;
-        // set base url if not defined in environment variables
-        if (!envVars.getString(EnvironmentVariable.SC_BASE_URL)) {
-            this.debug(`Environment variable '${EnvironmentVariable.SC_BASE_URL}' not set, using default '${DefaultBaseUrl}'`);
-            envVars.setString(EnvironmentVariable.SC_BASE_URL, DefaultBaseUrl);
-        }
-        // Check if Access Token is set
-        const value = envVars.getString(EnvironmentVariable.SC_ACCESS_TOKEN);
-        if (!value) {
-            this.error(`Environment variable ${EnvironmentVariable.SC_ACCESS_TOKEN} is not set and required for any API operations.`);
-        }
     }
 }

package/lib/util/sc-connection.d.ts

@@ -1,8 +1,16 @@
 import { AxiosRequestConfig } from 'axios';
+export type HttpAuthType = 'basic' | 'bearer';
+export type ApiType = 'cloud' | 'semp';
+export interface ScConnectionOptions {
+    apiType?: ApiType;
+    apiVersion?: string;
+    authType?: HttpAuthType;
+    timeout?: number;
+}
 export declare class ScConnection {
     private axiosInstance;
     private endpointUrl;
-    constructor(baseURL?: string, accessToken?: string, timeout?: number, basic?: boolean);
+    constructor(baseURL: string, accessToken: string, options?: ScConnectionOptions);
     delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
     get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
     patch<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;

package/lib/util/sc-connection.js

@@ -1,23 +1,33 @@
 import axios from 'axios';
-import { DefaultBaseUrl, EnvironmentVariable, envVars } from '../config/env-vars.js';
 export class ScConnection {
     axiosInstance;
     endpointUrl = '';
-    constructor(baseURL = envVars.getString(EnvironmentVariable.SC_BASE_URL, DefaultBaseUrl), accessToken = envVars.getString(EnvironmentVariable.SC_ACCESS_TOKEN, ''), timeout = 10_000, basic = false) {
-        const apiVersion = envVars.getString(EnvironmentVariable.SC_API_VERSION, 'v2');
-        const sempApiVersion = envVars.getString(EnvironmentVariable.SEMP_API_VERSION, 'v2');
-        this.endpointUrl = basic
-            ? this.joinPaths(baseURL, `/SEMP/${sempApiVersion}`)
-            : this.joinPaths(baseURL, `/api/${apiVersion}`);
+    constructor(baseURL, accessToken, options) {
+        // Validate required parameters
+        if (!baseURL || baseURL.trim() === '') {
+            throw new Error('baseURL is required and cannot be empty');
+        }
+        if (!accessToken || accessToken.trim() === '') {
+            throw new Error('accessToken is required and cannot be empty');
+        }
+        // Extract options with defaults
+        const { apiType = 'cloud', apiVersion = 'v2', authType = 'bearer', timeout = 10_000 } = options ?? {};
+        // Build endpoint URL based on apiType
+        // For SEMP: use baseURL directly (version specified in actual API calls)
+        // For cloud: append /api/{version}
+        const apiPath = apiType === 'semp' ? '' : `/api/${apiVersion}`;
+        this.endpointUrl = apiPath ? this.joinPaths(baseURL, apiPath) : baseURL;
+        // Build authorization header based on authType
+        const authHeader = authType === 'basic' ? `Basic ${accessToken}` : `Bearer ${accessToken}`;
         this.axiosInstance = axios.create({
             baseURL: this.endpointUrl,
             headers: {
-                Authorization: basic ? `Basic ${accessToken}` : `Bearer ${accessToken}`,
+                Authorization: authHeader,
                 'Content-Type': 'application/json',
             },
             timeout,
         });
-        // Add interceptors if needed
+        // Add interceptors
         this.axiosInstance.interceptors.response.use((response) => response, (error) => {
             console.error('API Error:', error.response?.data || error.message);
             return Promise.reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dishantlangayan/sc-cli-core",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Base library for the Solace Cloud CLI and plugins",
   "license": "Apache-2.0",
   "author": "Dishant Langayan",