@smythos/sre 1.6.1 → 1.6.8

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

@@ -1,101 +1,101 @@
-import { Agent } from './Agent.class';
-
-export class AgentSSE {
-    private connections: Map<string, any> = new Map();
-
-    /**
-     * Creates a new AgentSSE instance
-     * @param agent - The agent instance this SSE belongs to
-     */
-    constructor(private agent: Agent) {}
-
-    /**
-     * Updates or adds a response object with the given monitor ID
-     * Maintains backward compatibility by also setting the res property
-     * @param res - The response object to add or update
-     * @param monitorId - The monitor ID associated with this connection
-     * @returns The connection ID that was created or updated
-     */
-    public add(res: any, monitorId: string) {
-        // Store the connection
-        this.connections.set(monitorId, res);
-    }
-
-    public [Symbol.iterator](): IterableIterator<[string, any]> {
-        return this.connections.entries();
-    }
-
-    /**
-     * Sends an event to all connected clients
-     * @param _type - The event type
-     * @param _data - The event data
-     */
-    public async send(_type: string, _data: any): Promise<void> {
-        if (!_type || !_data) return;
-
-        // Format the data once
-        const data = typeof _data === 'string' ? _data : JSON.stringify(_data);
-        const message = `event: ${_type}\ndata: ${data}\n\n`;
-
-        // Send to all connections
-        for (const [id, connection] of this.connections.entries()) {
-            try {
-                if (connection && !connection.finished) {
-                    connection.write(message);
-                } else {
-                    // Remove closed connections
-                    this.connections.delete(id);
-                }
-            } catch (error) {
-                // Handle errors (connection might be closed)
-                console.error(`Error sending SSE to connection ${id}:`, error);
-                this.connections.delete(id);
-            }
-        }
-    }
-
-    /**
-     * Removes a specific connection
-     * @param connectionId - The ID of the connection to remove
-     * @returns True if the connection was found and removed, false otherwise
-     */
-    public remove(connectionId: string): boolean {
-        const connection = this.connections.get(connectionId);
-        if (connection) {
-            try {
-                if (connection && !connection.finished) {
-                    connection.end();
-                }
-            } catch (error) {
-                console.error(`Error closing connection ${connectionId}:`, error);
-            }
-            return this.connections.delete(connectionId);
-        }
-        return false;
-    }
-
-    /**
-     * Closes all connections
-     */
-    public async close(): Promise<void> {
-        for (const [id, connection] of this.connections.entries()) {
-            try {
-                if (connection && !connection.finished) {
-                    connection.end();
-                    console.log('Delibertly shutting down sse connection with id: ', id);
-                }
-            } catch (error) {
-                console.error(`Error closing connection ${id}:`, error);
-            }
-        }
-        this.connections.clear();
-    }
-
-    /**
-     * Gets the number of active connections
-     * @returns The number of active connections
-     */
-    public getConnectionCount(): number {
-        return this.connections.size;
-    }
-}
+import { Agent } from './Agent.class';
+
+export class AgentSSE {
+    private connections: Map<string, any> = new Map();
+
+    /**
+     * Creates a new AgentSSE instance
+     * @param agent - The agent instance this SSE belongs to
+     */
+    constructor(private agent: Agent) {}
+
+    /**
+     * Updates or adds a response object with the given monitor ID
+     * Maintains backward compatibility by also setting the res property
+     * @param res - The response object to add or update
+     * @param monitorId - The monitor ID associated with this connection
+     * @returns The connection ID that was created or updated
+     */
+    public add(res: any, monitorId: string) {
+        // Store the connection
+        this.connections.set(monitorId, res);
+    }
+
+    public [Symbol.iterator](): IterableIterator<[string, any]> {
+        return this.connections.entries();
+    }
+
+    /**
+     * Sends an event to all connected clients
+     * @param _type - The event type
+     * @param _data - The event data
+     */
+    public async send(_type: string, _data: any): Promise<void> {
+        if (!_type || !_data) return;
+
+        // Format the data once
+        const data = typeof _data === 'string' ? _data : JSON.stringify(_data);
+        const message = `event: ${_type}\ndata: ${data}\n\n`;
+
+        // Send to all connections
+        for (const [id, connection] of this.connections.entries()) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.write(message);
+                } else {
+                    // Remove closed connections
+                    this.connections.delete(id);
+                }
+            } catch (error) {
+                // Handle errors (connection might be closed)
+                console.error(`Error sending SSE to connection ${id}:`, error);
+                this.connections.delete(id);
+            }
+        }
+    }
+
+    /**
+     * Removes a specific connection
+     * @param connectionId - The ID of the connection to remove
+     * @returns True if the connection was found and removed, false otherwise
+     */
+    public remove(connectionId: string): boolean {
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.end();
+                }
+            } catch (error) {
+                console.error(`Error closing connection ${connectionId}:`, error);
+            }
+            return this.connections.delete(connectionId);
+        }
+        return false;
+    }
+
+    /**
+     * Closes all connections
+     */
+    public async close(): Promise<void> {
+        for (const [id, connection] of this.connections.entries()) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.end();
+                    console.log('Delibertly shutting down sse connection with id: ', id);
+                }
+            } catch (error) {
+                console.error(`Error closing connection ${id}:`, error);
+            }
+        }
+        this.connections.clear();
+    }
+
+    /**
+     * Gets the number of active connections
+     * @returns The number of active connections
+     */
+    public getConnectionCount(): number {
+        return this.connections.size;
+    }
+}

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

@@ -1,52 +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];
-    }
-}
+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

@@ -1,32 +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;
-    }
-}
+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

@@ -1,60 +1,60 @@
-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();
-
-        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
-        //Grant read access by default
-        //acl.addAccess(TAccessRole.Team, teamId, TAccessLevel.Read).addAccess(candidate.role, candidate.id, TAccessLevel.Read);
-
-        return acl;
-    }
-}
+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();
+
+        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+        //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

@@ -1,11 +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);
-    }
-}
+//==[ 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

@@ -1,47 +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;
-    }
-}
+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;
+    }
+}