@smythos/sre 1.5.53 → 1.5.54

package/src/subsystems/Security/Account.service/connectors/JSONFileAccount.class.ts

@@ -1,159 +1,159 @@
-import { Connector } from '@sre/Core/Connector.class';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { SecureConnector } from '@sre/Security/SecureConnector.class';
-import { DEFAULT_TEAM_ID, IAccessCandidate, IACL, TAccessRole } from '@sre/types/ACL.types';
-import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
-import { AccountConnector } from '../AccountConnector';
-import { KeyValueObject } from '@sre/types/Common.types';
-import * as fs from 'fs';
-import * as path from 'path';
-
-/*
-JSONAccount format 
-
-{
-    "team1": {
-        users: {
-            "user1": {
-                "settings": {
-                    "setting1": "value1",
-                    "setting2": "value2"
-                }
-            }
-        },
-        "agents": {
-            "agent1": {
-                "settings": {
-                    "setting1": "value1",
-                    "setting2": "value2"
-                }
-            }
-        },
-        "settings": {
-            "setting1": "value1",
-            "setting2": "value2"
-        }
-    }
-}
-
-*/
-
-export type TJSONFileAccountSettings = {
-    file: string;
-};
-
-export class JSONFileAccount extends AccountConnector {
-    public name = 'JSONFileAccount';
-    private data: any = {};
-    private file: string;
-
-    constructor(protected _settings: TJSONFileAccountSettings) {
-        super(_settings);
-        this.file = _settings.file;
-        this.loadData();
-    }
-
-    private loadData() {
-        try {
-            const fileContent = fs.readFileSync(this.file, 'utf-8');
-            this.data = JSON.parse(fileContent);
-        } catch (error) {
-            console.error('Error loading JSON account data:', error);
-            this.data = {};
-        }
-    }
-
-    private saveData() {
-        try {
-            fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
-        } catch (error) {
-            console.error('Error saving JSON account data:', error);
-        }
-    }
-
-    public async isTeamMember(team: string, candidate: IAccessCandidate): Promise<boolean> {
-        if (!this.data[team]) return false;
-
-        if (candidate.role === TAccessRole.User) {
-            return !!this.data[team].users?.[candidate.id];
-        } else if (candidate.role === TAccessRole.Agent) {
-            return !!this.data[team].agents?.[candidate.id];
-        }
-
-        return false;
-    }
-
-    public async getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined> {
-        if (candidate.role === TAccessRole.Team) {
-            return candidate.id;
-        }
-
-        // Search through all teams to find where the candidate belongs
-        for (const [teamId, teamData] of Object.entries(this.data)) {
-            const typedTeamData = teamData as { users?: Record<string, any>; agents?: Record<string, any> };
-            if (candidate.role === TAccessRole.User && typedTeamData.users?.[candidate.id]) {
-                return teamId;
-            }
-            if (candidate.role === TAccessRole.Agent && typedTeamData.agents?.[candidate.id]) {
-                return teamId;
-            }
-        }
-
-        return DEFAULT_TEAM_ID;
-    }
-
-    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
-        throw new Error('getResourceACL Method not implemented.');
-    }
-
-    public async getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject[]> {
-        if (!this.data[teamId]?.settings) return [];
-
-        return Object.entries(this.data[teamId].settings).map(([key, value]) => ({
-            key,
-            value: value as string,
-        }));
-    }
-
-    public async getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject[]> {
-        // Search through all teams to find user settings
-        for (const teamData of Object.values(this.data)) {
-            const typedTeamData = teamData as { users?: Record<string, { settings?: Record<string, any> }> };
-            if (typedTeamData.users?.[accountId]?.settings) {
-                return Object.entries(typedTeamData.users[accountId].settings).map(([key, value]) => ({
-                    key,
-                    value: value as string,
-                }));
-            }
-        }
-        return [];
-    }
-
-    public async getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string> {
-        return this.data[teamId]?.settings?.[settingKey] || '';
-    }
-
-    public async getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string> {
-        // Search through all teams to find user setting
-        for (const teamData of Object.values(this.data)) {
-            const typedTeamData = teamData as { users?: Record<string, { settings?: Record<string, any> }> };
-            if (typedTeamData.users?.[accountId]?.settings?.[settingKey]) {
-                return typedTeamData.users[accountId].settings[settingKey];
-            }
-        }
-        return '';
-    }
-
-    public async getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string> {
-        // Search through all teams to find agent setting
-        for (const teamData of Object.values(this.data)) {
-            const typedTeamData = teamData as { agents?: Record<string, { settings?: Record<string, any> }> };
-            if (typedTeamData.agents?.[agentId]?.settings?.[settingKey]) {
-                return typedTeamData.agents[agentId].settings[settingKey];
-            }
-        }
-        return '';
-    }
-}
+import { Connector } from '@sre/Core/Connector.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { DEFAULT_TEAM_ID, IAccessCandidate, IACL, TAccessRole } from '@sre/types/ACL.types';
+import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
+import { AccountConnector } from '../AccountConnector';
+import { KeyValueObject } from '@sre/types/Common.types';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/*
+JSONAccount format 
+
+{
+    "team1": {
+        users: {
+            "user1": {
+                "settings": {
+                    "setting1": "value1",
+                    "setting2": "value2"
+                }
+            }
+        },
+        "agents": {
+            "agent1": {
+                "settings": {
+                    "setting1": "value1",
+                    "setting2": "value2"
+                }
+            }
+        },
+        "settings": {
+            "setting1": "value1",
+            "setting2": "value2"
+        }
+    }
+}
+
+*/
+
+export type TJSONFileAccountSettings = {
+    file: string;
+};
+
+export class JSONFileAccount extends AccountConnector {
+    public name = 'JSONFileAccount';
+    private data: any = {};
+    private file: string;
+
+    constructor(protected _settings: TJSONFileAccountSettings) {
+        super(_settings);
+        this.file = _settings.file;
+        this.loadData();
+    }
+
+    private loadData() {
+        try {
+            const fileContent = fs.readFileSync(this.file, 'utf-8');
+            this.data = JSON.parse(fileContent);
+        } catch (error) {
+            console.error('Error loading JSON account data:', error);
+            this.data = {};
+        }
+    }
+
+    private saveData() {
+        try {
+            fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+        } catch (error) {
+            console.error('Error saving JSON account data:', error);
+        }
+    }
+
+    public async isTeamMember(team: string, candidate: IAccessCandidate): Promise<boolean> {
+        if (!this.data[team]) return false;
+
+        if (candidate.role === TAccessRole.User) {
+            return !!this.data[team].users?.[candidate.id];
+        } else if (candidate.role === TAccessRole.Agent) {
+            return !!this.data[team].agents?.[candidate.id];
+        }
+
+        return false;
+    }
+
+    public async getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined> {
+        if (candidate.role === TAccessRole.Team) {
+            return candidate.id;
+        }
+
+        // Search through all teams to find where the candidate belongs
+        for (const [teamId, teamData] of Object.entries(this.data)) {
+            const typedTeamData = teamData as { users?: Record<string, any>; agents?: Record<string, any> };
+            if (candidate.role === TAccessRole.User && typedTeamData.users?.[candidate.id]) {
+                return teamId;
+            }
+            if (candidate.role === TAccessRole.Agent && typedTeamData.agents?.[candidate.id]) {
+                return teamId;
+            }
+        }
+
+        return DEFAULT_TEAM_ID;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        throw new Error('getResourceACL Method not implemented.');
+    }
+
+    public async getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject[]> {
+        if (!this.data[teamId]?.settings) return [];
+
+        return Object.entries(this.data[teamId].settings).map(([key, value]) => ({
+            key,
+            value: value as string,
+        }));
+    }
+
+    public async getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject[]> {
+        // Search through all teams to find user settings
+        for (const teamData of Object.values(this.data)) {
+            const typedTeamData = teamData as { users?: Record<string, { settings?: Record<string, any> }> };
+            if (typedTeamData.users?.[accountId]?.settings) {
+                return Object.entries(typedTeamData.users[accountId].settings).map(([key, value]) => ({
+                    key,
+                    value: value as string,
+                }));
+            }
+        }
+        return [];
+    }
+
+    public async getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string> {
+        return this.data[teamId]?.settings?.[settingKey] || '';
+    }
+
+    public async getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string> {
+        // Search through all teams to find user setting
+        for (const teamData of Object.values(this.data)) {
+            const typedTeamData = teamData as { users?: Record<string, { settings?: Record<string, any> }> };
+            if (typedTeamData.users?.[accountId]?.settings?.[settingKey]) {
+                return typedTeamData.users[accountId].settings[settingKey];
+            }
+        }
+        return '';
+    }
+
+    public async getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string> {
+        // Search through all teams to find agent setting
+        for (const teamData of Object.values(this.data)) {
+            const typedTeamData = teamData as { agents?: Record<string, { settings?: Record<string, any> }> };
+            if (typedTeamData.agents?.[agentId]?.settings?.[settingKey]) {
+                return typedTeamData.agents[agentId].settings[settingKey];
+            }
+        }
+        return '';
+    }
+}

package/src/subsystems/Security/Account.service/index.ts

@@ -1,14 +1,14 @@
-//==[ SRE: LLM ]======================
-
-import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { DummyAccount } from './connectors/DummyAccount.class';
-import { AWSAccount } from './connectors/AWSAccount.class';
-import { JSONFileAccount } from './connectors/JSONFileAccount.class';
-export class AccountService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.Account, 'AWSAccount', AWSAccount);
-        ConnectorService.register(TConnectorService.Account, 'DummyAccount', DummyAccount);
-        ConnectorService.register(TConnectorService.Account, 'JSONFileAccount', JSONFileAccount);
-    }
-}
+//==[ SRE: LLM ]======================
+
+import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { DummyAccount } from './connectors/DummyAccount.class';
+import { AWSAccount } from './connectors/AWSAccount.class';
+import { JSONFileAccount } from './connectors/JSONFileAccount.class';
+export class AccountService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Account, 'AWSAccount', AWSAccount);
+        ConnectorService.register(TConnectorService.Account, 'DummyAccount', DummyAccount);
+        ConnectorService.register(TConnectorService.Account, 'JSONFileAccount', JSONFileAccount);
+    }
+}

package/src/subsystems/Security/Credentials.helper.ts

@@ -1,62 +1,62 @@
-import { AccessCandidate } from '../..';
-import { ConnectorService } from '../../Core/ConnectorsService';
-
-export type TCredentialsRequest = {
-    vaultProvider?: string;
-    keyName: string;
-    mapping?: {
-        [key: string]: string;
-    };
-};
-
-/**
- * Get credentials from a vault
- *
- * @param candidate - The candidate requesting the credentials
- * @param credentialsRequest - The credentials request
- * @returns The credentials
- */
-export async function getCredentials(
-    candidate: AccessCandidate,
-    credentialsRequest: TCredentialsRequest | string
-): Promise<string | Record<string, any>> {
-    if (typeof credentialsRequest === 'string') {
-        credentialsRequest = {
-            vaultProvider: '', //default vault provider
-            keyName: credentialsRequest, //default key name
-        };
-    }
-
-    const vaultConnector = ConnectorService.getVaultConnector(credentialsRequest.vaultProvider || '');
-    const vaultRequester = vaultConnector.requester(candidate);
-    const credentials = await vaultRequester.get(credentialsRequest.keyName);
-
-    if (!credentialsRequest.mapping) return credentials;
-
-    const mappedCredentials = {};
-    for (const [key, value] of Object.entries(credentialsRequest.mapping)) {
-        mappedCredentials[key] = JSONExpression(credentials, value);
-    }
-
-    return mappedCredentials;
-}
-
-/**
- * @param obj - The object to extract the property from
- * @param propertyString - The property to extract from the object
- * @returns The property value
- */
-function JSONExpression(obj, propertyString) {
-    const properties = propertyString.split(/\.|\[|\]\.|\]\[|\]/).filter(Boolean);
-    let currentProperty = obj;
-
-    for (let property of properties) {
-        if (currentProperty === undefined || currentProperty === null) {
-            return undefined;
-        }
-
-        currentProperty = currentProperty[property];
-    }
-
-    return currentProperty;
-}
+import { AccessCandidate } from '../..';
+import { ConnectorService } from '../../Core/ConnectorsService';
+
+export type TCredentialsRequest = {
+    vaultProvider?: string;
+    keyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+};
+
+/**
+ * Get credentials from a vault
+ *
+ * @param candidate - The candidate requesting the credentials
+ * @param credentialsRequest - The credentials request
+ * @returns The credentials
+ */
+export async function getCredentials(
+    candidate: AccessCandidate,
+    credentialsRequest: TCredentialsRequest | string
+): Promise<string | Record<string, any>> {
+    if (typeof credentialsRequest === 'string') {
+        credentialsRequest = {
+            vaultProvider: '', //default vault provider
+            keyName: credentialsRequest, //default key name
+        };
+    }
+
+    const vaultConnector = ConnectorService.getVaultConnector(credentialsRequest.vaultProvider || '');
+    const vaultRequester = vaultConnector.requester(candidate);
+    const credentials = await vaultRequester.get(credentialsRequest.keyName);
+
+    if (!credentialsRequest.mapping) return credentials;
+
+    const mappedCredentials = {};
+    for (const [key, value] of Object.entries(credentialsRequest.mapping)) {
+        mappedCredentials[key] = JSONExpression(credentials, value);
+    }
+
+    return mappedCredentials;
+}
+
+/**
+ * @param obj - The object to extract the property from
+ * @param propertyString - The property to extract from the object
+ * @returns The property value
+ */
+function JSONExpression(obj, propertyString) {
+    const properties = propertyString.split(/\.|\[|\]\.|\]\[|\]/).filter(Boolean);
+    let currentProperty = obj;
+
+    for (let property of properties) {
+        if (currentProperty === undefined || currentProperty === null) {
+            return undefined;
+        }
+
+        currentProperty = currentProperty[property];
+    }
+
+    return currentProperty;
+}

package/src/subsystems/Security/ManagedVault.service/ManagedVaultConnector.ts

@@ -1,38 +1,38 @@
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { SecureConnector } from '@sre/Security/SecureConnector.class';
-import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
-
-/**
- * The managed vault is a vault that is managed by the SRE, its keys are not visible to the user.
- * it's used to store generated tokens at runtime, like OAuth tokens
- */
-
-export interface IManagedVaultRequest {
-    get(keyId: string): Promise<string>;
-    set(keyId: string, value: string): Promise<void>;
-    delete(keyId: string): Promise<void>;
-    exists(keyId: string): Promise<boolean>;
-}
-
-export abstract class ManagedVaultConnector extends SecureConnector {
-    constructor(protected _settings?: any) {
-        super(_settings);
-    }
-
-    requester(candidate: AccessCandidate): IManagedVaultRequest {
-        return {
-            get: async (keyId: string) => this.get(candidate.readRequest, keyId),
-            set: async (keyId: string, value: string) => this.set(candidate.writeRequest, keyId, value),
-            delete: async (keyId: string) => this.delete(candidate.writeRequest, keyId),
-            exists: async (keyId: string) => this.exists(candidate.readRequest, keyId),
-        };
-    }
-
-    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    protected abstract get(acRequest: AccessRequest, keyId: string): Promise<string>;
-    protected abstract set(acRequest: AccessRequest, keyId: string, value: string): Promise<void>;
-    protected abstract delete(acRequest: AccessRequest, keyId: string): Promise<void>;
-    protected abstract exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
-}
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+
+/**
+ * The managed vault is a vault that is managed by the SRE, its keys are not visible to the user.
+ * it's used to store generated tokens at runtime, like OAuth tokens
+ */
+
+export interface IManagedVaultRequest {
+    get(keyId: string): Promise<string>;
+    set(keyId: string, value: string): Promise<void>;
+    delete(keyId: string): Promise<void>;
+    exists(keyId: string): Promise<boolean>;
+}
+
+export abstract class ManagedVaultConnector extends SecureConnector {
+    constructor(protected _settings?: any) {
+        super(_settings);
+    }
+
+    requester(candidate: AccessCandidate): IManagedVaultRequest {
+        return {
+            get: async (keyId: string) => this.get(candidate.readRequest, keyId),
+            set: async (keyId: string, value: string) => this.set(candidate.writeRequest, keyId, value),
+            delete: async (keyId: string) => this.delete(candidate.writeRequest, keyId),
+            exists: async (keyId: string) => this.exists(candidate.readRequest, keyId),
+        };
+    }
+
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract get(acRequest: AccessRequest, keyId: string): Promise<string>;
+    protected abstract set(acRequest: AccessRequest, keyId: string, value: string): Promise<void>;
+    protected abstract delete(acRequest: AccessRequest, keyId: string): Promise<void>;
+    protected abstract exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+}

package/src/subsystems/Security/ManagedVault.service/connectors/NullManagedVault.class.ts

@@ -1,53 +1,53 @@
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { Logger } from '@sre/helpers/Log.helper';
-//import { SmythRuntime } from '@sre/Core/SmythRuntime.class';
-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 } from '@sre/types/ACL.types';
-
-import { ManagedVaultConnector } from '../ManagedVaultConnector';
-
-const console = Logger('NullManagedVault');
-export class NullManagedVault extends ManagedVaultConnector {
-    public name: string = 'NullManagedVault';
-
-    constructor(protected _settings: any) {
-        super(_settings);
-    }
-
-    @SecureConnector.AccessControl
-    protected async get(acRequest: AccessRequest, keyId: string) {
-        console.debug(`Ignored operation:NullManagedVault.get: ${keyId}`);
-        return undefined;
-    }
-
-    @SecureConnector.AccessControl
-    protected async set(acRequest: AccessRequest, keyId: string, value: string) {
-        console.debug(`Ignored operation:NullManagedVault.set: ${keyId} = ${value}`);
-    }
-
-    @SecureConnector.AccessControl
-    protected async delete(acRequest: AccessRequest, keyId: string) {
-        console.debug(`Ignored operation:NullManagedVault.delete: ${keyId}`);
-    }
-
-    @SecureConnector.AccessControl
-    protected async exists(acRequest: AccessRequest, keyId: string) {
-        console.debug(`Ignored operation:NullManagedVault.exists: ${keyId}`);
-        return false;
-    }
-
-    public async getResourceACL(resourceId: string, candidate: IAccessCandidate) {
-        const accountConnector = ConnectorService.getAccountConnector();
-        const teamId = await accountConnector.getCandidateTeam(candidate);
-
-        const acl = new ACL();
-
-        //give just read access by default
-        //Cannot write to null vault
-        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
-
-        return acl;
-    }
-}
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { Logger } from '@sre/helpers/Log.helper';
+//import { SmythRuntime } from '@sre/Core/SmythRuntime.class';
+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 } from '@sre/types/ACL.types';
+
+import { ManagedVaultConnector } from '../ManagedVaultConnector';
+
+const console = Logger('NullManagedVault');
+export class NullManagedVault extends ManagedVaultConnector {
+    public name: string = 'NullManagedVault';
+
+    constructor(protected _settings: any) {
+        super(_settings);
+    }
+
+    @SecureConnector.AccessControl
+    protected async get(acRequest: AccessRequest, keyId: string) {
+        console.debug(`Ignored operation:NullManagedVault.get: ${keyId}`);
+        return undefined;
+    }
+
+    @SecureConnector.AccessControl
+    protected async set(acRequest: AccessRequest, keyId: string, value: string) {
+        console.debug(`Ignored operation:NullManagedVault.set: ${keyId} = ${value}`);
+    }
+
+    @SecureConnector.AccessControl
+    protected async delete(acRequest: AccessRequest, keyId: string) {
+        console.debug(`Ignored operation:NullManagedVault.delete: ${keyId}`);
+    }
+
+    @SecureConnector.AccessControl
+    protected async exists(acRequest: AccessRequest, keyId: string) {
+        console.debug(`Ignored operation:NullManagedVault.exists: ${keyId}`);
+        return false;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate) {
+        const accountConnector = ConnectorService.getAccountConnector();
+        const teamId = await accountConnector.getCandidateTeam(candidate);
+
+        const acl = new ACL();
+
+        //give just read access by default
+        //Cannot write to null vault
+        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+
+        return acl;
+    }
+}