@smythos/sre 1.5.1 → 1.5.4

package/src/subsystems/AgentManager/AgentSettings.class.ts

@@ -0,0 +1,52 @@
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { EmbodimentSettings } from './EmbodimentSettings.class';
+
+import { Logger } from '@sre/helpers/Log.helper';
+const console = Logger('AgentSettings');
+
+export class AgentSettings {
+    private _settings: any;
+    public embodiments?: EmbodimentSettings;
+    private _ready = false;
+
+    constructor(agentId?) {
+        if (agentId) {
+            this.init(agentId);
+        }
+    }
+
+    async init(agentId) {
+        // Set embodiments before _settings allow us to use it immediately; otherwise, we need to wait both AgentSettings instance and EmbodimentSettings instance to be ready
+        this.embodiments = new EmbodimentSettings(agentId);
+
+        const agentDataConnector = ConnectorService.getAgentDataConnector();
+        this._settings = (await agentDataConnector.getAgentSettings(agentId).catch((e) => {})) || {};
+        this._ready = true;
+    }
+
+    public ready(maxWait = 10000) {
+        return new Promise((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (this._ready) {
+                    clearInterval(interval);
+                    resolve(true);
+                }
+                maxWait -= 100;
+            }, 100);
+
+            setTimeout(() => {
+                clearInterval(interval);
+                reject(false);
+            }, maxWait);
+        });
+    }
+    public get(key: string) {
+        return this._settings?.[key] || '';
+    }
+    public set(key: string, value: any) {
+        this._settings[key] = value;
+    }
+    public has(key: string) {
+        return this._settings[key];
+    }
+}

package/src/subsystems/AgentManager/Component.service/ComponentConnector.ts

@@ -0,0 +1,32 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+
+export interface IComponentRequest {
+    register(componentName: string, componentInstance: any): Promise<void>;
+    get(componentName: string): Promise<any>;
+    getAll(): Promise<any>;
+}
+
+export abstract class ComponentConnector extends SecureConnector {
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract register(acRequest: AccessRequest, componentName: string, componentInstance: any): Promise<void>;
+    protected abstract get(acRequest: AccessRequest, componentName: string): Promise<any>;
+    protected abstract getAll(acRequest: AccessRequest): Promise<any>;
+
+    public requester(candidate: AccessCandidate): IComponentRequest {
+        return {
+            register: async (componentName: string, componentInstance: any) => {
+                return await this.register(candidate.readRequest, componentName, componentInstance);
+            },
+            get: async (componentName: string) => {
+                return await this.get(candidate.readRequest, componentName);
+            },
+            getAll: async () => {
+                return await this.getAll(candidate.readRequest);
+            },
+        } as IComponentRequest;
+    }
+}

package/src/subsystems/AgentManager/Component.service/connectors/LocalComponentConnector.class.ts

@@ -0,0 +1,59 @@
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { Logger } from '@sre/helpers/Log.helper';
+
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate, TAccessLevel, TAccessRole } from '@sre/types/ACL.types';
+
+import { ComponentConnector } from '../ComponentConnector';
+import { ComponentInstances } from '@sre/Components/index';
+
+const console = Logger('LocalComponentConnector');
+
+//TODO : future : Candidate specific components access : we can rely on the ACL to isolate the components per user/agent/team
+export class LocalComponentConnector extends ComponentConnector {
+    public name: string = 'LocalComponentConnector';
+    private components: any = {};
+
+    constructor() {
+        super();
+
+        this.init();
+    }
+
+    async init() {
+        for (const component in ComponentInstances) {
+            this.components[component] = ComponentInstances[component];
+        }
+        console.debug('Registering Components :', Object.keys(this.components).join(', '));
+    }
+
+    @SecureConnector.AccessControl
+    protected async register(acRequest: AccessRequest, componentName: string, componentInstance: any) {
+        this.components[componentName] = componentInstance;
+    }
+
+    @SecureConnector.AccessControl
+    protected async get(acRequest: AccessRequest, componentName: string) {
+        return this.components[componentName];
+    }
+
+    @SecureConnector.AccessControl
+    protected async getAll(acRequest: AccessRequest) {
+        return this.components;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate) {
+        const accountConnector = ConnectorService.getAccountConnector();
+
+        const teamId = await accountConnector.getCandidateTeam(candidate);
+
+        const acl = new ACL();
+
+        //Grant read access by default
+        acl.addAccess(TAccessRole.Team, teamId, TAccessLevel.Read).addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+
+        return acl;
+    }
+}

package/src/subsystems/AgentManager/Component.service/index.ts

@@ -0,0 +1,11 @@
+//==[ SRE: Component ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { LocalComponentConnector } from './connectors/LocalComponentConnector.class';
+
+export class ComponentService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Component, 'LocalComponent', LocalComponentConnector);
+    }
+}

package/src/subsystems/AgentManager/EmbodimentSettings.class.ts

@@ -0,0 +1,47 @@
+import { Logger } from '@sre/helpers/Log.helper';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+const console = Logger('EmbodimentSettings');
+
+export class EmbodimentSettings {
+    private _embodiments: any;
+    private _ready = false;
+
+    constructor(agentId) {
+        this.init(agentId);
+    }
+
+    async init(agentId) {
+        const agentDataConnector = ConnectorService.getAgentDataConnector();
+        this._embodiments = await agentDataConnector.getAgentEmbodiments(agentId).catch((error) => []);
+        this._ready = true;
+    }
+    public ready(maxWait = 10000) {
+        return new Promise((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (this._ready) {
+                    clearInterval(interval);
+                    resolve(true);
+                }
+                maxWait -= 100;
+            }, 100);
+
+            setTimeout(() => {
+                clearInterval(interval);
+                reject(false);
+            }, maxWait);
+        });
+    }
+
+    public get(embodimentType: string, key?: string) {
+        if (!this._embodiments) return undefined;
+        const _embodiment = this._embodiments.find((embodiment: any) => embodiment.type?.toLowerCase() === embodimentType.toLowerCase());
+
+        if (!_embodiment) {
+            //console.error(`Error: No ${embodimentType} embodiment found for agent`);
+        }
+        if (key) {
+            return _embodiment?.properties?.[key];
+        }
+        return _embodiment?.properties;
+    }
+}

package/src/subsystems/AgentManager/ForkedAgent.class.ts

@@ -0,0 +1,153 @@
+import { IAgent } from '@sre/types/Agent.types';
+import { Agent } from './Agent.class';
+import { AgentRequest } from './AgentRequest.class';
+
+import { Logger } from '@sre/helpers/Log.helper';
+import { uid } from '@sre/utils';
+const console = Logger('ForkedAgent');
+
+/**
+ * This class creates a forked agent from a parent agent branch, it allows running a sub-branch of the parent agent asynchrounously by providing a separate agent context
+ * We use composition instead of inheritance to avoid circular dependencies between Agent and ForkedAgent
+ */
+export class ForkedAgent {
+    public agent: IAgent;
+    public get agentRequest() {
+        return this.agent.agentRequest;
+    }
+    public get components() {
+        return this.agent.components;
+    }
+    public get agentRuntime() {
+        return this.agent.agentRuntime;
+    }
+    public get jobID() {
+        return this.agent.jobID;
+    }
+    constructor(
+        private parent: IAgent,
+        componentId: string, //the component to fork from
+    ) {
+        const data: any = fork(this.parent.data, componentId);
+        data.variables = JSON.parse(JSON.stringify(this.parent?.data?.variables || {})); //copy parent Agent variables to forked agent
+        data.teamId = this.parent.teamId;
+        //TODO : we need to create a default APIEndpoint bound to the root component if root component is not an APIEndpoint
+        const content = { name: this.parent.name, data, teamId: this.parent.teamId, debugSessionEnabled: false, version: this.parent.version };
+
+        const agentRequest = new AgentRequest(this.parent.agentRequest.req);
+        agentRequest.headers = []; //clear all headers from parent agent to conflict with child agent
+
+        this.agent = new Agent(this.parent.id, content, this.parent.agentSettings, agentRequest);
+        const JobID = componentId + '-' + uid();
+        this.agent.jobID = JobID;
+        //since the jobID was updated we need to create a different runtime
+        //FIXME : we need to find a way to avoid creating default runtime for forked agents, then replace it
+        //this.agent.agentRuntime = new AgentRuntime(this.agent);
+
+        //super(parent.id, content, agentRequest);
+    }
+
+    process(path: string, input: any) {
+        return this.agent.process(path, input);
+    }
+}
+
+// Helper function to clone a component and update its ID
+function cloneComponent(component) {
+    const newComponent = JSON.parse(JSON.stringify(component));
+    newComponent.id = component.id;
+    return newComponent;
+}
+
+// Helper function to recursively clone components and their connections
+function cloneRecursively(componentData, currentID, newIDMap, clonedComponents, clonedConnections) {
+    const componentToClone = componentData.components.find((c) => c.id === currentID);
+    if (!componentToClone) {
+        return;
+    }
+
+    const clonedComponent = cloneComponent(componentToClone);
+    newIDMap[currentID] = clonedComponent.id; // Map old ID to new ID
+    clonedComponents.push(clonedComponent);
+
+    // Find all outgoing connections for the current component
+    const outgoingConnections = componentData.connections.filter((conn) => conn.sourceId === currentID);
+    outgoingConnections.forEach((conn) => {
+        // Clone the connection and update the IDs
+        const clonedConnection = JSON.parse(JSON.stringify(conn));
+        clonedConnection.sourceId = clonedComponent.id;
+        if (!newIDMap[conn.targetId]) {
+            // Recursively clone the connected component if it hasn't been cloned yet
+            cloneRecursively(componentData, conn.targetId, newIDMap, clonedComponents, clonedConnections);
+        }
+        clonedConnection.targetId = newIDMap[conn.targetId];
+        clonedConnections.push(clonedConnection);
+    });
+}
+
+function fork(componentData, componentID) {
+    const clonedComponents: any[] = [];
+    const clonedConnections: any[] = [];
+    const newIDMap = {}; // Map to keep track of old to new ID mappings
+
+    // Start the cloning process from the specified component ID
+    cloneRecursively(componentData, componentID, newIDMap, clonedComponents, clonedConnections);
+
+    const rootComponentData = clonedComponents.find((e) => e.id == componentID);
+    if (rootComponentData) {
+        if (rootComponentData.name !== 'APIEndpoint') {
+            const APIEndpointData: any = {
+                id: `${componentID}_ENDPOINT`,
+                name: 'APIEndpoint',
+                outputs: [
+                    { name: 'headers', index: 0, default: true },
+                    { name: 'body', index: 1, default: true },
+                    { name: 'query', index: 2, default: true },
+                ],
+                inputs: [],
+                data: { endpoint: componentID, description: '', method: 'POST' },
+                displayName: 'APIEndpoint',
+                title: 'APIEndpoint',
+                description: '',
+            };
+
+            //APIEndpointData.inputs = JSON.parse(JSON.stringify(rootComponentData.inputs));
+            clonedComponents.push(APIEndpointData);
+
+            //find all previously connected forked inputs
+            const incomingConnections = componentData.connections.filter((conn) => conn.targetId === componentID);
+            // //deduplicate connections by targetId
+            // const uniqueIncomingConnections = incomingConnections.filter(
+            //     (conn, index, self) => index === self.findIndex((t) => t.targetId === conn.targetId && t.sourceIndex === conn.sourceIndex && t.targetIndex === conn.targetIndex),
+            // );
+
+            let i = 3;
+            for (let con of incomingConnections) {
+                const input = rootComponentData.inputs.find((e) => e.index == con.targetIndex);
+                const epInput = JSON.parse(JSON.stringify(input));
+                APIEndpointData.inputs.push(epInput);
+
+                const epOutput = {
+                    name: input.name,
+                    expression: `body.${input.name}`,
+                    optional: false,
+                    index: i++,
+                    default: false,
+                };
+                APIEndpointData.outputs.push(epOutput);
+
+                clonedConnections.push({
+                    sourceId: APIEndpointData.id,
+                    targetId: rootComponentData.id,
+                    sourceIndex: epOutput.index,
+                    targetIndex: input.index,
+                });
+            }
+        }
+    }
+    // Return the cloned sub-workflow
+    return {
+        components: clonedComponents,
+        connections: clonedConnections,
+    };
+}

package/src/subsystems/AgentManager/OSResourceMonitor.ts

@@ -0,0 +1,77 @@
+import os from 'os';
+import process from 'process';
+
+const OSResourceMonitor: any = {
+    mem: getMemoryUsage(),
+    //processMemory: getProcessMemoryUsage(),
+    cpu: getCpuUsage(),
+    //processCpu: getProcessCpuUsage(),
+};
+export { OSResourceMonitor };
+
+function getCpuUsage() {
+    const cpus = os.cpus();
+    let user = 0;
+    let nice = 0;
+    let sys = 0;
+    let idle = 0;
+    let irq = 0;
+    let total = 0;
+
+    for (let cpu of cpus) {
+        user += cpu.times.user;
+        nice += cpu.times.nice;
+        sys += cpu.times.sys;
+        idle += cpu.times.idle;
+        irq += cpu.times.irq;
+    }
+
+    total = user + nice + sys + idle + irq;
+
+    return {
+        user: (user / total) * 100,
+        sys: (sys / total) * 100,
+        idle: (idle / total) * 100,
+        load: 100 - (idle / total) * 100,
+    };
+}
+
+function getMemoryUsage() {
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    const usedMemory = totalMemory - freeMemory;
+
+    return {
+        totalMemory: (totalMemory / 1024 ** 3).toFixed(2) + ' GB',
+        freeMemory: (freeMemory / 1024 ** 3).toFixed(2) + ' GB',
+        usedMemory: (usedMemory / 1024 ** 3).toFixed(2) + ' GB',
+        memoryUsagePercentage: ((usedMemory / totalMemory) * 100).toFixed(2),
+    };
+}
+
+function getProcessMemoryUsage() {
+    const memoryUsage = process.memoryUsage();
+    return {
+        total: memoryUsage.rss,
+        heapTotal: (memoryUsage.heapTotal / 1024 ** 2).toFixed(2) + ' MB',
+        heapUsed: (memoryUsage.heapUsed / 1024 ** 2).toFixed(2) + ' MB',
+        external: (memoryUsage.external / 1024 ** 2).toFixed(2) + ' MB',
+    };
+}
+
+function getProcessCpuUsage() {
+    const cpuUsage = process.cpuUsage();
+    return {
+        user: cpuUsage.user,
+        system: cpuUsage.system,
+    };
+}
+
+function logSystemUsage() {
+    OSResourceMonitor.mem = getMemoryUsage();
+    OSResourceMonitor.cpu = getCpuUsage();
+    //OSResourceMonitor.processMemory = getProcessMemoryUsage();
+    //OSResourceMonitor.processCpu = getProcessCpuUsage();
+}
+
+//setInterval(logSystemUsage, 5000); // update every 5 seconds

package/src/subsystems/ComputeManager/Code.service/CodeConnector.ts

@@ -0,0 +1,99 @@
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+
+export interface CodeInput {
+    code: string; // Main code to execute
+    dependencies?: string; // Dependencies/imports/packages
+    files?: Record<string, string>; // Additional files (filename -> content)
+    inputs?: Record<string, any>; // Runtime input parameters
+}
+
+export interface CodeConfig {
+    runtime: string; // 'nodejs', 'python', 'java', etc.
+    timeout?: number; // Execution timeout in milliseconds
+    memoryLimit?: number; // Memory allocation in MB
+    environment?: Record<string, string>; // Environment variables
+
+    // Platform-specific settings
+    platformConfig?: Record<string, any>;
+}
+
+export interface CodeExecutionResult {
+    output: any; // The execution result/return value
+    executionTime: number; // Execution time in milliseconds
+    logs?: string[]; // Execution logs
+    errors?: string[]; // Error messages
+    success: boolean; // Whether execution succeeded
+}
+
+export interface CodePreparationResult {
+    prepared: boolean; // Whether preparation succeeded
+    errors?: string[]; // Preparation errors
+    warnings?: string[]; // Preparation warnings
+    metadata?: Record<string, any>; // Platform-specific preparation data
+}
+
+export interface CodeDeployment {
+    id: string; // Deployment identifier
+    status: 'deploying' | 'ready' | 'failed';
+    runtime: string;
+    createdAt: Date;
+    lastUsed?: Date;
+}
+
+export interface ICodeRequest {
+    // Core workflow
+    prepare(input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+
+    // Execute with existing deployment (for platforms that support it)
+    executeDeployment(deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+
+    // Deployment management
+    listDeployments(): Promise<CodeDeployment[]>;
+    getDeployment(deploymentId: string): Promise<CodeDeployment | null>;
+    deleteDeployment(deploymentId: string): Promise<void>;
+}
+
+export abstract class CodeConnector extends SecureConnector {
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+
+    // Abstract methods that concrete connectors must implement
+    protected abstract prepare(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    protected abstract deploy(acRequest: AccessRequest, deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    protected abstract execute(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract executeDeployment(acRequest: AccessRequest, deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+    protected abstract listDeployments(acRequest: AccessRequest): Promise<CodeDeployment[]>;
+    protected abstract getDeployment(acRequest: AccessRequest, deploymentId: string): Promise<CodeDeployment | null>;
+    protected abstract deleteDeployment(acRequest: AccessRequest, deploymentId: string): Promise<void>;
+
+    public requester(candidate: AccessCandidate): ICodeRequest {
+        return {
+            prepare: async (input: CodeInput, config: CodeConfig) => {
+                return await this.prepare(candidate.readRequest, input, config);
+            },
+            deploy: async (deploymentId: string, input: CodeInput, config: CodeConfig) => {
+                return await this.deploy(candidate.writeRequest, deploymentId, input, config);
+            },
+            execute: async (input: CodeInput, config: CodeConfig) => {
+                return await this.execute(candidate.readRequest, input, config);
+            },
+            executeDeployment: async (deploymentId: string, inputs: Record<string, any>) => {
+                return await this.executeDeployment(candidate.readRequest, deploymentId, inputs);
+            },
+            listDeployments: async () => {
+                return await this.listDeployments(candidate.readRequest);
+            },
+            getDeployment: async (deploymentId: string) => {
+                return await this.getDeployment(candidate.readRequest, deploymentId);
+            },
+            deleteDeployment: async (deploymentId: string) => {
+                await this.deleteDeployment(candidate.writeRequest, deploymentId);
+            },
+        } as ICodeRequest;
+    }
+}

package/src/subsystems/ComputeManager/Code.service/connectors/AWSLambdaCode.class.ts

@@ -0,0 +1,63 @@
+import { IAccessCandidate, TAccessLevel } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+
+export class AWSLambdaCode extends CodeConnector {
+    public name = 'AWSLambdaCode';
+
+    public async prepare(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult> {
+        return {
+            prepared: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+
+    public async deploy(acRequest: AccessRequest, deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment> {
+        return {
+            id: deploymentId,
+            runtime: config.runtime,
+            createdAt: new Date(),
+            status: 'deploying',
+        };
+    }
+
+    public async execute(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult> {
+        return {
+            output: {},
+            executionTime: 0,
+            success: true,
+        };
+    }
+
+    public async executeDeployment(acRequest: AccessRequest, deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult> {
+        return {
+            output: {},
+            executionTime: 0,
+            success: true,
+        };
+    }
+
+    public async listDeployments(acRequest: AccessRequest): Promise<CodeDeployment[]> {
+        return [];
+    }
+
+    public async getDeployment(acRequest: AccessRequest, deploymentId: string): Promise<CodeDeployment | null> {
+        return null;
+    }
+
+    public async deleteDeployment(acRequest: AccessRequest, deploymentId: string): Promise<void> {
+        return;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        const acl = new ACL();
+
+        //give Read access everytime
+        //FIXME: !!!!!! IMPORTANT !!!!!!  this implementation have to be changed in order to reflect the security model of AWS Lambda
+        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+
+        return acl;
+    }
+}

package/src/subsystems/ComputeManager/Code.service/index.ts

@@ -0,0 +1,11 @@
+//==[ SRE: Storage ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { AWSLambdaCode } from './connectors/AWSLambdaCode.class';
+
+export class CodeService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Code, 'AWSLambda', AWSLambdaCode);
+    }
+}

package/src/subsystems/IO/CLI.service/CLIConnector.ts

@@ -0,0 +1,47 @@
+import { Connector } from '@sre/Core/Connector.class';
+import { getMainArgs, parseCLIArgs } from '@sre/utils/cli.utils';
+
+export class CLIConnector extends Connector {
+    public name = 'CLI';
+    public params: any;
+    constructor(protected _settings?: any) {
+        super(_settings);
+        this.params = this.parse(process.argv);
+    }
+
+    /**
+     * Parses the command line arguments, and returns the parsed arguments object
+     * if args is provided, it will only parse the provided args
+     * @param argv The command line arguments, usually process.argv
+     * @param args The arguments to parse
+     * @returns
+     */
+    public parse(argv: string[], args?: string | string[]) {
+        let _keys = args;
+        if (_keys && !Array.isArray(_keys)) _keys = [_keys];
+
+        const argsList = _keys || getMainArgs(argv);
+        const params = parseCLIArgs(argsList, argv);
+
+        return params;
+    }
+
+    /**
+     * Get the parsed arguments as an object
+     * @param args The arguments to get
+     * @returns
+     */
+    public get(args: string | string[]) {
+        let _keys = args;
+        if (!Array.isArray(_keys)) _keys = [_keys];
+
+        const result = {};
+        _keys.forEach((key) => {
+            if (this.params[key]) {
+                result[key] = this.params[key];
+            }
+        });
+
+        return result;
+    }
+}

package/src/subsystems/IO/CLI.service/index.ts

@@ -0,0 +1,9 @@
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { CLIConnector } from './CLIConnector';
+
+export class CLIService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.CLI, 'CLI', CLIConnector);
+    }
+}