@dishantlangayan/sc-cli-core 0.5.3 → 0.7.0

package/lib/auth/auth-encryption.d.ts

@@ -1,9 +1,10 @@
-import { type BrokerAuthStorage, type EncryptedData } from './auth-types.js';
+import type { EncryptedData } from './auth-types.js';
 /**
- * Encryption utility for broker authentication storage
+ * Generic encryption utility for authentication storage
  * Uses AES-256-GCM for authenticated encryption
+ * Can be used by both OrgManager and BrokerAuthManager
  */
-export declare class BrokerAuthEncryption {
+export declare class AuthEncryption {
     private static readonly ALGORITHM;
     private static readonly DIGEST;
     private static readonly ITERATIONS;
@@ -17,7 +18,7 @@ export declare class BrokerAuthEncryption {
      * @param key - Decryption key
      * @returns Decrypted storage
      */
-    static decrypt<T = BrokerAuthStorage>(encryptedData: EncryptedData, key: Buffer): Promise<T>;
+    static decrypt<T>(encryptedData: EncryptedData, key: Buffer): Promise<T>;
     /**
      * Derive encryption key from password using PBKDF2
      * @param password - User password
@@ -31,7 +32,7 @@ export declare class BrokerAuthEncryption {
      * @param key - Encryption key
      * @returns Encrypted data with metadata
      */
-    static encrypt<T = BrokerAuthStorage>(data: T, key: Buffer): Promise<EncryptedData>;
+    static encrypt<T>(data: T, key: Buffer): Promise<EncryptedData>;
     /**
      * Generate cryptographically secure random salt
      * @returns Random salt buffer

package/lib/auth/auth-encryption.js

@@ -1,12 +1,12 @@
 import { createCipheriv, createDecipheriv, pbkdf2, randomBytes } from 'node:crypto';
 import { promisify } from 'node:util';
-import { BrokerAuthError, BrokerAuthErrorCode } from './auth-types.js';
 const pbkdf2Async = promisify(pbkdf2);
 /**
- * Encryption utility for broker authentication storage
+ * Generic encryption utility for authentication storage
  * Uses AES-256-GCM for authenticated encryption
+ * Can be used by both OrgManager and BrokerAuthManager
  */
-export class BrokerAuthEncryption {
+export class AuthEncryption {
     static ALGORITHM = 'aes-256-gcm';
     static DIGEST = 'sha256';
     static ITERATIONS = 100_000; // OWASP recommended minimum for PBKDF2
@@ -36,7 +36,9 @@ export class BrokerAuthEncryption {
             return storage;
         }
         catch (error) {
-            throw new BrokerAuthError('Failed to decrypt broker storage. The password may be incorrect or the file may be corrupted.', BrokerAuthErrorCode.DECRYPTION_FAILED, error);
+            const err = new Error('Failed to decrypt storage. The password may be incorrect or the file may be corrupted.');
+            err.cause = error;
+            throw err;
         }
     }
     /**
@@ -48,15 +50,17 @@ export class BrokerAuthEncryption {
     static async deriveKey(password, salt) {
         try {
             if (!password || password.length === 0) {
-                throw new BrokerAuthError('Password cannot be empty', BrokerAuthErrorCode.INVALID_PASSWORD);
+                throw new Error('Password cannot be empty');
             }
             return await pbkdf2Async(password, salt, this.ITERATIONS, this.KEY_LENGTH, this.DIGEST);
         }
         catch (error) {
-            if (error instanceof BrokerAuthError) {
+            if (error instanceof Error && error.message === 'Password cannot be empty') {
                 throw error;
             }
-            throw new BrokerAuthError('Failed to derive encryption key', BrokerAuthErrorCode.ENCRYPTION_FAILED, error);
+            const err = new Error('Failed to derive encryption key');
+            err.cause = error;
+            throw err;
         }
     }
     /**
@@ -93,7 +97,9 @@ export class BrokerAuthEncryption {
             };
         }
         catch (error) {
-            throw new BrokerAuthError('Failed to encrypt broker storage', BrokerAuthErrorCode.ENCRYPTION_FAILED, error);
+            const err = new Error('Failed to encrypt storage');
+            err.cause = error;
+            throw err;
         }
     }
     /**

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

@@ -1,46 +1,3 @@
-/**
- * Authentication types supported by the broker auth system
- */
-export declare enum AuthType {
-    BASIC = "basic",
-    OAUTH = "oauth"
-}
-/**
- * Base broker authentication configuration
- */
-export interface BrokerAuthBase {
-    authType: AuthType;
-    name: string;
-    sempEndpoint: string;
-    sempPort: number;
-}
-/**
- * OAuth broker authentication configuration
- */
-export interface OAuthBrokerAuth extends BrokerAuthBase {
-    accessToken: string;
-    authType: AuthType.OAUTH;
-    clientId: string;
-    refreshToken: string;
-}
-/**
- * Basic authentication broker configuration
- */
-export interface BasicBrokerAuth extends BrokerAuthBase {
-    authType: AuthType.BASIC;
-    encodedCredentials: string;
-}
-/**
- * Union type for broker authentication
- */
-export type BrokerAuth = BasicBrokerAuth | OAuthBrokerAuth;
-/**
- * Storage format for broker configurations
- */
-export interface BrokerAuthStorage {
-    brokers: BrokerAuth[];
-    version: string;
-}
 /**
  * Encryption metadata stored alongside encrypted data
  */
@@ -60,30 +17,3 @@ export interface EncryptedData {
     metadata: EncryptionMetadata;
     salt: string;
 }
-/**
- * Error codes for broker auth operations
- */
-export declare enum BrokerAuthErrorCode {
-    BROKER_ALREADY_EXISTS = "BROKER_ALREADY_EXISTS",
-    BROKER_NOT_FOUND = "BROKER_NOT_FOUND",
-    DECRYPTION_FAILED = "DECRYPTION_FAILED",
-    ENCRYPTION_FAILED = "ENCRYPTION_FAILED",
-    FILE_READ_ERROR = "FILE_READ_ERROR",
-    FILE_WRITE_ERROR = "FILE_WRITE_ERROR",
-    INVALID_AUTH_TYPE = "INVALID_AUTH_TYPE",
-    INVALID_BASIC_CONFIG = "INVALID_BASIC_CONFIG",
-    INVALID_ENDPOINT = "INVALID_ENDPOINT",
-    INVALID_NAME = "INVALID_NAME",
-    INVALID_OAUTH_CONFIG = "INVALID_OAUTH_CONFIG",
-    INVALID_PASSWORD = "INVALID_PASSWORD",
-    INVALID_PORT = "INVALID_PORT",
-    NOT_INITIALIZED = "NOT_INITIALIZED"
-}
-/**
- * Custom error class for broker authentication operations
- */
-export declare class BrokerAuthError extends Error {
-    readonly code: BrokerAuthErrorCode;
-    readonly cause?: Error | undefined;
-    constructor(message: string, code: BrokerAuthErrorCode, cause?: Error | undefined);
-}

package/lib/auth/auth-types.js

@@ -1,41 +1 @@
-/**
- * Authentication types supported by the broker auth system
- */
-export var AuthType;
-(function (AuthType) {
-    AuthType["BASIC"] = "basic";
-    AuthType["OAUTH"] = "oauth";
-})(AuthType || (AuthType = {}));
-/**
- * Error codes for broker auth operations
- */
-export var BrokerAuthErrorCode;
-(function (BrokerAuthErrorCode) {
-    BrokerAuthErrorCode["BROKER_ALREADY_EXISTS"] = "BROKER_ALREADY_EXISTS";
-    BrokerAuthErrorCode["BROKER_NOT_FOUND"] = "BROKER_NOT_FOUND";
-    BrokerAuthErrorCode["DECRYPTION_FAILED"] = "DECRYPTION_FAILED";
-    BrokerAuthErrorCode["ENCRYPTION_FAILED"] = "ENCRYPTION_FAILED";
-    BrokerAuthErrorCode["FILE_READ_ERROR"] = "FILE_READ_ERROR";
-    BrokerAuthErrorCode["FILE_WRITE_ERROR"] = "FILE_WRITE_ERROR";
-    BrokerAuthErrorCode["INVALID_AUTH_TYPE"] = "INVALID_AUTH_TYPE";
-    BrokerAuthErrorCode["INVALID_BASIC_CONFIG"] = "INVALID_BASIC_CONFIG";
-    BrokerAuthErrorCode["INVALID_ENDPOINT"] = "INVALID_ENDPOINT";
-    BrokerAuthErrorCode["INVALID_NAME"] = "INVALID_NAME";
-    BrokerAuthErrorCode["INVALID_OAUTH_CONFIG"] = "INVALID_OAUTH_CONFIG";
-    BrokerAuthErrorCode["INVALID_PASSWORD"] = "INVALID_PASSWORD";
-    BrokerAuthErrorCode["INVALID_PORT"] = "INVALID_PORT";
-    BrokerAuthErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
-})(BrokerAuthErrorCode || (BrokerAuthErrorCode = {}));
-/**
- * Custom error class for broker authentication operations
- */
-export class BrokerAuthError extends Error {
-    code;
-    cause;
-    constructor(message, code, cause) {
-        super(message);
-        this.code = code;
-        this.cause = cause;
-        this.name = 'BrokerAuthError';
-    }
-}
+export {};

package/lib/auth/{auth-manager.d.ts → broker-auth-manager.d.ts}

@@ -1,5 +1,5 @@
 import { ScConnection } from '../util/sc-connection.js';
-import { type BrokerAuth } from './auth-types.js';
+import { type BrokerAuth } from './broker-auth-types.js';
 import { KeychainService } from './keychain.js';
 /**
  * Manager for broker authentication storage
@@ -53,6 +53,11 @@ export declare class BrokerAuthManager {
      * @returns Broker configuration or null if not found
      */
     getBroker(name: string): Promise<BrokerAuth | null>;
+    /**
+     * Get the default broker
+     * @returns Default broker or null if no default is set
+     */
+    getDefaultBroker(): Promise<BrokerAuth | null>;
     /**
      * Initialize the auth manager with encryption key derived from OS keychain and machine ID
      */
@@ -67,6 +72,11 @@ export declare class BrokerAuthManager {
      * @param name - Broker name to remove
      */
     removeBroker(name: string): Promise<void>;
+    /**
+     * Set a broker as the default
+     * @param name - Broker name to set as default
+     */
+    setDefaultBroker(name: string): Promise<void>;
     /**
      * Update existing broker configuration
      * @param name - Broker name to update
@@ -90,6 +100,10 @@ export declare class BrokerAuthManager {
      * Save storage to encrypted file
      */
     private saveStorage;
+    /**
+     * Unset the default flag on all brokers
+     */
+    private unsetAllDefaults;
     /**
      * Validate broker configuration
      * @param broker - Broker to validate

package/lib/auth/{auth-manager.js → broker-auth-manager.js}

@@ -2,8 +2,8 @@ import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ScConnection } from '../util/sc-connection.js';
-import { BrokerAuthEncryption } from './auth-encryption.js';
-import { AuthType, BrokerAuthError, BrokerAuthErrorCode, } from './auth-types.js';
+import { AuthEncryption } from './auth-encryption.js';
+import { AuthType, BrokerAuthError, BrokerAuthErrorCode, } from './broker-auth-types.js';
 import { KeychainService } from './keychain.js';
 const SERVICE_NAME = 'local';
 const KEY_NAME = 'sc-cli';
@@ -49,6 +49,10 @@ export class BrokerAuthManager {
         if (existing) {
             throw new BrokerAuthError(`Broker '${broker.name}' already exists`, BrokerAuthErrorCode.BROKER_ALREADY_EXISTS);
         }
+        // If this broker is being set as default, unset any existing default
+        if (broker.isDefault) {
+            this.unsetAllDefaults();
+        }
         // Add broker
         this.storage.brokers.push(broker);
         // Save to file
@@ -84,7 +88,7 @@ export class BrokerAuthManager {
             throw new BrokerAuthError(`Broker '${brokerName}' not found`, BrokerAuthErrorCode.BROKER_NOT_FOUND);
         }
         const baseURL = `${broker.sempEndpoint}:${broker.sempPort}`;
-        const accessToken = broker.authType === AuthType.OAUTH ? broker.accessToken : broker.encodedCredentials;
+        const { accessToken } = broker;
         return new ScConnection(baseURL, accessToken, {
             apiType: 'semp',
             authType: broker.authType === AuthType.BASIC ? 'basic' : 'bearer',
@@ -109,6 +113,15 @@ export class BrokerAuthManager {
         const broker = this.storage.brokers.find((b) => b.name === name);
         return broker ?? null;
     }
+    /**
+     * Get the default broker
+     * @returns Default broker or null if no default is set
+     */
+    async getDefaultBroker() {
+        this.ensureInitialized();
+        const broker = this.storage.brokers.find((b) => b.isDefault === true);
+        return broker ?? null;
+    }
     /**
      * Initialize the auth manager with encryption key derived from OS keychain and machine ID
      */
@@ -133,8 +146,8 @@ export class BrokerAuthManager {
             }
             else {
                 // Create new storage with new salt
-                const salt = BrokerAuthEncryption.generateSalt();
-                this.encryptionKey = await BrokerAuthEncryption.deriveKey(combinedKey, salt);
+                const salt = AuthEncryption.generateSalt();
+                this.encryptionKey = await AuthEncryption.deriveKey(combinedKey, salt);
                 this.storage = {
                     brokers: [],
                     version: '1.0.0',
@@ -171,6 +184,23 @@ export class BrokerAuthManager {
         // Save to file
         await this.saveStorage();
     }
+    /**
+     * Set a broker as the default
+     * @param name - Broker name to set as default
+     */
+    async setDefaultBroker(name) {
+        this.ensureInitialized();
+        const index = this.storage.brokers.findIndex((b) => b.name === name);
+        if (index === -1) {
+            throw new BrokerAuthError(`Broker '${name}' not found`, BrokerAuthErrorCode.BROKER_NOT_FOUND);
+        }
+        // Unset all existing defaults
+        this.unsetAllDefaults();
+        // Set this broker as default
+        this.storage.brokers[index].isDefault = true;
+        // Save to file
+        await this.saveStorage();
+    }
     /**
      * Update existing broker configuration
      * @param name - Broker name to update
@@ -182,6 +212,10 @@ export class BrokerAuthManager {
         if (index === -1) {
             throw new BrokerAuthError(`Broker '${name}' not found`, BrokerAuthErrorCode.BROKER_NOT_FOUND);
         }
+        // If setting this broker as default, unset any existing default
+        if (updates.isDefault === true) {
+            this.unsetAllDefaults();
+        }
         // Merge updates
         const updated = {
             ...this.storage.brokers[index],
@@ -225,9 +259,9 @@ export class BrokerAuthManager {
             const encryptedData = JSON.parse(fileContent);
             // Derive key from combined key and stored salt
             const salt = Buffer.from(encryptedData.salt, 'base64');
-            this.encryptionKey = await BrokerAuthEncryption.deriveKey(combinedKey, salt);
+            this.encryptionKey = await AuthEncryption.deriveKey(combinedKey, salt);
             // Decrypt storage
-            this.storage = await BrokerAuthEncryption.decrypt(encryptedData, this.encryptionKey);
+            this.storage = await AuthEncryption.decrypt(encryptedData, this.encryptionKey);
         }
         catch (error) {
             if (error instanceof BrokerAuthError) {
@@ -246,12 +280,16 @@ export class BrokerAuthManager {
             }
             // Ensure directory exists
             await mkdir(this.configDir, { mode: 0o700, recursive: true });
-            // Encrypt data
-            const encrypted = await BrokerAuthEncryption.encrypt(this.storage, this.encryptionKey);
-            // Re-derive key with new salt for next save
+            // Generate new salt and derive key for THIS save
             const combinedKey = `${this.masterKey}:${this.machineId}`;
-            const newSalt = Buffer.from(encrypted.salt, 'base64');
-            this.encryptionKey = await BrokerAuthEncryption.deriveKey(combinedKey, newSalt);
+            const newSalt = AuthEncryption.generateSalt();
+            const newKey = await AuthEncryption.deriveKey(combinedKey, newSalt);
+            // Encrypt data with the new key
+            const encrypted = await AuthEncryption.encrypt(this.storage, newKey);
+            // Update the salt in encrypted data to match the salt we used for key derivation
+            encrypted.salt = newSalt.toString('base64');
+            // Store the new key for next operation
+            this.encryptionKey = newKey;
             // Write to temp file first (atomic write)
             const jsonData = JSON.stringify(encrypted, null, 2);
             const tempFile = `${this.configFile}.tmp`;
@@ -277,6 +315,14 @@ export class BrokerAuthManager {
             throw new BrokerAuthError('Failed to save broker storage', BrokerAuthErrorCode.FILE_WRITE_ERROR, error);
         }
     }
+    /**
+     * Unset the default flag on all brokers
+     */
+    unsetAllDefaults() {
+        for (const broker of this.storage.brokers) {
+            broker.isDefault = false;
+        }
+    }
     /**
      * Validate broker configuration
      * @param broker - Broker to validate
@@ -294,19 +340,13 @@ export class BrokerAuthManager {
         if (broker.sempPort < 1 || broker.sempPort > 65_535) {
             throw new BrokerAuthError('SEMP port must be between 1 and 65535', BrokerAuthErrorCode.INVALID_PORT);
         }
-        // Validate auth-specific fields
-        if (broker.authType === AuthType.OAUTH) {
-            if (!broker.accessToken || !broker.clientId) {
-                throw new BrokerAuthError('OAuth brokers require accessToken and clientId', BrokerAuthErrorCode.INVALID_OAUTH_CONFIG);
-            }
-        }
-        else if (broker.authType === AuthType.BASIC) {
-            if (!broker.encodedCredentials) {
-                throw new BrokerAuthError('Basic auth brokers require encodedCredentials', BrokerAuthErrorCode.INVALID_BASIC_CONFIG);
-            }
-        }
-        else {
+        // Validate auth type
+        if (broker.authType !== AuthType.OAUTH && broker.authType !== AuthType.BASIC) {
             throw new BrokerAuthError('Invalid auth type', BrokerAuthErrorCode.INVALID_AUTH_TYPE);
         }
+        // Validate access token
+        if (!broker.accessToken || broker.accessToken.trim() === '') {
+            throw new BrokerAuthError('Access token is required', BrokerAuthErrorCode.INVALID_ACCESS_TOKEN);
+        }
     }
 }

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

@@ -0,0 +1,57 @@
+/**
+ * Authentication types supported by the broker auth system
+ */
+export declare enum AuthType {
+    BASIC = "basic",
+    OAUTH = "oauth"
+}
+/**
+ * Broker authentication configuration
+ *
+ * @property {string} accessToken - For OAuth: access token string. For Basic: base64-encoded credentials
+ * @property {AuthType} authType - Type of authentication (BASIC or OAUTH)
+ * @property {string} name - Human-readable name/alias for the broker
+ * @property {string} sempEndpoint - SEMP endpoint URL (must start with http:// or https://)
+ * @property {number} sempPort - SEMP port number (1-65535)
+ */
+export interface BrokerAuth {
+    accessToken: string;
+    authType: AuthType;
+    isDefault?: boolean;
+    name: string;
+    sempEndpoint: string;
+    sempPort: number;
+}
+/**
+ * Storage format for broker configurations
+ */
+export interface BrokerAuthStorage {
+    brokers: BrokerAuth[];
+    version: string;
+}
+/**
+ * Error codes for broker auth operations
+ */
+export declare enum BrokerAuthErrorCode {
+    BROKER_ALREADY_EXISTS = "BROKER_ALREADY_EXISTS",
+    BROKER_NOT_FOUND = "BROKER_NOT_FOUND",
+    DECRYPTION_FAILED = "DECRYPTION_FAILED",
+    ENCRYPTION_FAILED = "ENCRYPTION_FAILED",
+    FILE_READ_ERROR = "FILE_READ_ERROR",
+    FILE_WRITE_ERROR = "FILE_WRITE_ERROR",
+    INVALID_ACCESS_TOKEN = "INVALID_ACCESS_TOKEN",
+    INVALID_AUTH_TYPE = "INVALID_AUTH_TYPE",
+    INVALID_ENDPOINT = "INVALID_ENDPOINT",
+    INVALID_NAME = "INVALID_NAME",
+    INVALID_PASSWORD = "INVALID_PASSWORD",
+    INVALID_PORT = "INVALID_PORT",
+    NOT_INITIALIZED = "NOT_INITIALIZED"
+}
+/**
+ * Custom error class for broker authentication operations
+ */
+export declare class BrokerAuthError extends Error {
+    readonly code: BrokerAuthErrorCode;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: BrokerAuthErrorCode, cause?: Error | undefined);
+}

package/lib/auth/broker-auth-types.js

@@ -0,0 +1,40 @@
+/**
+ * Authentication types supported by the broker auth system
+ */
+export var AuthType;
+(function (AuthType) {
+    AuthType["BASIC"] = "basic";
+    AuthType["OAUTH"] = "oauth";
+})(AuthType || (AuthType = {}));
+/**
+ * Error codes for broker auth operations
+ */
+export var BrokerAuthErrorCode;
+(function (BrokerAuthErrorCode) {
+    BrokerAuthErrorCode["BROKER_ALREADY_EXISTS"] = "BROKER_ALREADY_EXISTS";
+    BrokerAuthErrorCode["BROKER_NOT_FOUND"] = "BROKER_NOT_FOUND";
+    BrokerAuthErrorCode["DECRYPTION_FAILED"] = "DECRYPTION_FAILED";
+    BrokerAuthErrorCode["ENCRYPTION_FAILED"] = "ENCRYPTION_FAILED";
+    BrokerAuthErrorCode["FILE_READ_ERROR"] = "FILE_READ_ERROR";
+    BrokerAuthErrorCode["FILE_WRITE_ERROR"] = "FILE_WRITE_ERROR";
+    BrokerAuthErrorCode["INVALID_ACCESS_TOKEN"] = "INVALID_ACCESS_TOKEN";
+    BrokerAuthErrorCode["INVALID_AUTH_TYPE"] = "INVALID_AUTH_TYPE";
+    BrokerAuthErrorCode["INVALID_ENDPOINT"] = "INVALID_ENDPOINT";
+    BrokerAuthErrorCode["INVALID_NAME"] = "INVALID_NAME";
+    BrokerAuthErrorCode["INVALID_PASSWORD"] = "INVALID_PASSWORD";
+    BrokerAuthErrorCode["INVALID_PORT"] = "INVALID_PORT";
+    BrokerAuthErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+})(BrokerAuthErrorCode || (BrokerAuthErrorCode = {}));
+/**
+ * Custom error class for broker authentication operations
+ */
+export class BrokerAuthError extends Error {
+    code;
+    cause;
+    constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'BrokerAuthError';
+    }
+}

package/lib/auth/index.d.ts

@@ -2,8 +2,9 @@
  * 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 { AuthEncryption } from './auth-encryption.js';
+export { type EncryptedData, type EncryptionMetadata } from './auth-types.js';
+export { BrokerAuthManager } from './broker-auth-manager.js';
+export { AuthType, type BrokerAuth, BrokerAuthError, BrokerAuthErrorCode, type BrokerAuthStorage, } from './broker-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

@@ -2,8 +2,8 @@
  * 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 { AuthEncryption } from './auth-encryption.js';
+export { BrokerAuthManager } from './broker-auth-manager.js';
+export { AuthType, BrokerAuthError, BrokerAuthErrorCode, } from './broker-auth-types.js';
 export { OrgManager } from './org-manager.js';
 export { OrgError, OrgErrorCode } from './org-types.js';

package/lib/auth/org-manager.js

@@ -3,7 +3,7 @@ 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 { AuthEncryption } from './auth-encryption.js';
 import { KeychainService } from './keychain.js';
 import { OrgError, OrgErrorCode } from './org-types.js';
 const SERVICE_NAME = 'local';
@@ -151,8 +151,8 @@ export class OrgManager {
             }
             else {
                 // Create new storage with new salt
-                const salt = BrokerAuthEncryption.generateSalt();
-                this.encryptionKey = await BrokerAuthEncryption.deriveKey(combinedKey, salt);
+                const salt = AuthEncryption.generateSalt();
+                this.encryptionKey = await AuthEncryption.deriveKey(combinedKey, salt);
                 this.storage = {
                     orgs: [],
                     version: '1.0.0',
@@ -280,9 +280,9 @@ export class OrgManager {
             const encryptedData = JSON.parse(fileContent);
             // Derive key from combined key and stored salt
             const salt = Buffer.from(encryptedData.salt, 'base64');
-            this.encryptionKey = await BrokerAuthEncryption.deriveKey(combinedKey, salt);
+            this.encryptionKey = await AuthEncryption.deriveKey(combinedKey, salt);
             // Decrypt storage
-            this.storage = await BrokerAuthEncryption.decrypt(encryptedData, this.encryptionKey);
+            this.storage = await AuthEncryption.decrypt(encryptedData, this.encryptionKey);
         }
         catch (error) {
             if (error instanceof OrgError) {
@@ -316,10 +316,10 @@ export class OrgManager {
             await mkdir(this.configDir, { mode: 0o700, recursive: true });
             // Generate new salt and derive key for THIS save
             const combinedKey = `${this.masterKey}:${this.machineId}`;
-            const newSalt = BrokerAuthEncryption.generateSalt();
-            const newKey = await BrokerAuthEncryption.deriveKey(combinedKey, newSalt);
+            const newSalt = AuthEncryption.generateSalt();
+            const newKey = await AuthEncryption.deriveKey(combinedKey, newSalt);
             // Encrypt data with the new key
-            const encrypted = await BrokerAuthEncryption.encrypt(this.storage, newKey);
+            const encrypted = await AuthEncryption.encrypt(this.storage, newKey);
             // Update the salt in encrypted data to match the salt we used for key derivation
             encrypted.salt = newSalt.toString('base64');
             // Store the new key for next operation

package/lib/exported.d.ts

@@ -1,4 +1,4 @@
-export { AuthType, type BasicBrokerAuth, type BrokerAuth, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, type OAuthBrokerAuth, type OrgConfig, OrgError, OrgErrorCode, OrgManager, type OrgStorage, } from './auth/index.js';
+export { AuthType, type BrokerAuth, BrokerAuthError, BrokerAuthErrorCode, BrokerAuthManager, 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 { type ApiType, type HttpAuthType, ScConnection, type ScConnectionOptions } from './util/sc-connection.js';

package/lib/sc-command.d.ts

@@ -1,5 +1,5 @@
 import { Command, Interfaces } from '@oclif/core';
-import { BrokerAuthManager } from './auth/auth-manager.js';
+import { BrokerAuthManager } from './auth/broker-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']>;

package/lib/sc-command.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { BrokerAuthManager } from './auth/auth-manager.js';
+import { BrokerAuthManager } from './auth/broker-auth-manager.js';
 import { OrgManager } from './auth/org-manager.js';
 /**
  * A base command that provided common functionality for all sc commands.

package/package.json

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