@smythos/sre 1.6.1 → 1.6.8

package/src/helpers/ECMASandbox.helper.ts

@@ -1,64 +1,64 @@
-import 'ses';
-
-export function runJs(code: string) {
-    // Ensure SES lockdown happens only once per process
-    // and tolerate environments already locked down elsewhere
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const globalAny: any = globalThis as any;
-    if (globalAny.__SRE_SES_LOCKED_DOWN__ !== true) {
-        try {
-            lockdown();
-        } catch (err) {
-            const msg = String(err || '');
-            if (!(msg.includes('Already locked down') || msg.includes('SES_ALREADY_LOCKED_DOWN'))) {
-                throw err;
-            }
-        } finally {
-            globalAny.__SRE_SES_LOCKED_DOWN__ = true;
-        }
-    }
-    try {
-        // Endow the compartment with necessary APIs
-        const compartment = new Compartment({
-            globals: {
-                // add necessary globals here
-                setTimeout: harden(setTimeout),
-                clearTimeout: harden(clearTimeout),
-                setInterval: harden(setInterval),
-                clearInterval: harden(clearInterval),
-                console: harden(console),
-                Promise: harden(Promise),
-                fetch: harden(fetch),
-            },
-            __options__: true, // temporary migration affordance
-        });
-        const result = compartment.evaluate(code);
-        return result;
-    } catch (error) {
-        console.error(error);
-        throw error;
-    }
-}
-
-function getParametersString(parameters: string[], inputs: Record<string, any>) {
-    let params = [];
-    for (const parameter of parameters) {
-        if (typeof inputs[parameter] === 'string') {
-            params.push(`'${inputs[parameter]}'`);
-        } else {
-            params.push(`${inputs[parameter]}`);
-        }
-    }
-    return params.join(',');
-}
-
-export function generateExecutableCode(code: string, parameters: string[], inputs: Record<string, any>) {
-    const executableCode = `
-    (async () => {
-        ${code}
-        const result = await main(${getParametersString(parameters, inputs)});
-        return result;
-    })();
-    `;
-    return executableCode;
-}
+import 'ses';
+
+export function runJs(code: string) {
+    // Ensure SES lockdown happens only once per process
+    // and tolerate environments already locked down elsewhere
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const globalAny: any = globalThis as any;
+    if (globalAny.__SRE_SES_LOCKED_DOWN__ !== true) {
+        try {
+            lockdown();
+        } catch (err) {
+            const msg = String(err || '');
+            if (!(msg.includes('Already locked down') || msg.includes('SES_ALREADY_LOCKED_DOWN'))) {
+                throw err;
+            }
+        } finally {
+            globalAny.__SRE_SES_LOCKED_DOWN__ = true;
+        }
+    }
+    try {
+        // Endow the compartment with necessary APIs
+        const compartment = new Compartment({
+            globals: {
+                // add necessary globals here
+                setTimeout: harden(setTimeout),
+                clearTimeout: harden(clearTimeout),
+                setInterval: harden(setInterval),
+                clearInterval: harden(clearInterval),
+                console: harden(console),
+                Promise: harden(Promise),
+                fetch: harden(fetch),
+            },
+            __options__: true, // temporary migration affordance
+        });
+        const result = compartment.evaluate(code);
+        return result;
+    } catch (error) {
+        console.error(error);
+        throw error;
+    }
+}
+
+function getParametersString(parameters: string[], inputs: Record<string, any>) {
+    let params = [];
+    for (const parameter of parameters) {
+        if (typeof inputs[parameter] === 'string') {
+            params.push(`'${inputs[parameter]}'`);
+        } else {
+            params.push(`${inputs[parameter]}`);
+        }
+    }
+    return params.join(',');
+}
+
+export function generateExecutableCode(code: string, parameters: string[], inputs: Record<string, any>) {
+    const executableCode = `
+    (async () => {
+        ${code}
+        const result = await main(${getParametersString(parameters, inputs)});
+        return result;
+    })();
+    `;
+    return executableCode;
+}

package/src/helpers/JsonContent.helper.ts

@@ -1,97 +1,97 @@
-import { jsonrepair } from 'jsonrepair';
-import { isDigits, isSafeNumber, isValidString } from '@sre/utils';
-
-export class JSONContentHelper {
-    private _current: string;
-
-    public get result() {
-        return this._current;
-    }
-    private constructor(private dataString: string) {
-        this._current = dataString;
-    }
-
-    public static create(dataString: string) {
-        return new JSONContentHelper(dataString);
-    }
-
-    /**
-     * This a permissive json parsing function : It tries to extract and parse a JSON object from a string. If it fails, it returns the original string.
-     * if the string is not a JSON representation, but contains a JSON object, it will extract and parse it.
-     * @returns
-     */
-    public tryParse() {
-        const strInput = this._current;
-
-        // is it an object ? a digit ? a safe number ?
-        if (!isValidString(strInput) || isDigits(strInput) || isSafeNumber(strInput)) return strInput;
-
-        let str = strInput.trim();
-
-        // the string seems to be a json object
-        if ((str.startsWith('{') && str.endsWith('}')) || (str.startsWith('[') && str.endsWith(']'))) {
-            try {
-                return JSON.parse(str);
-            } catch (e) {
-                try {
-                    const repairedJson = jsonrepair(str);
-                    return JSON.parse(repairedJson);
-                } catch (e: any) {}
-            }
-        }
-
-        // the string does not seem to be a json object, so we try to extract a json object from it
-        str = (this.extractJsonFromString(strInput) || strInput).trim();
-
-        if ((isDigits(str) && !isSafeNumber(str)) || (!str.startsWith('{') && !str.startsWith('['))) return str;
-
-        try {
-            return JSON.parse(str);
-        } catch (e) {
-            try {
-                const repairedJson = jsonrepair(str);
-                return JSON.parse(repairedJson);
-            } catch (e: any) {
-                //console.warn('Error on parseJson: ', e.toString());
-                //console.warn('   Tried to parse: ', str);
-                return strInput;
-            }
-        }
-    }
-
-    // Same as tryParse but it does not extract JSON from string
-    public tryFullParse() {
-        const str = this._current;
-        if (!str) return str;
-
-        if ((isDigits(str) && !isSafeNumber(str)) || (!str.startsWith('{') && !str.startsWith('['))) return str;
-
-        try {
-            return JSON.parse(str);
-        } catch (e) {
-            try {
-                return JSON.parse(jsonrepair(str));
-            } catch (e: any) {
-                console.warn('Error on parseJson: ', e.toString());
-                console.warn('   Tried to parse: ', str);
-                return { result: str, error: e.toString() };
-            }
-        }
-    }
-
-    private extractJsonFromString(str) {
-        try {
-            const regex = /(\{.*\})/s; // LLMs in smythOS are expected to generate json between curly brackets only
-
-            const match = str.match(regex);
-
-            return match?.[1];
-        } catch {
-            return null;
-        }
-    }
-}
-
-export function JSONContent(dataString: string) {
-    return JSONContentHelper.create(dataString);
-}
+import { jsonrepair } from 'jsonrepair';
+import { isDigits, isSafeNumber, isValidString } from '@sre/utils';
+
+export class JSONContentHelper {
+    private _current: string;
+
+    public get result() {
+        return this._current;
+    }
+    private constructor(private dataString: string) {
+        this._current = dataString;
+    }
+
+    public static create(dataString: string) {
+        return new JSONContentHelper(dataString);
+    }
+
+    /**
+     * This a permissive json parsing function : It tries to extract and parse a JSON object from a string. If it fails, it returns the original string.
+     * if the string is not a JSON representation, but contains a JSON object, it will extract and parse it.
+     * @returns
+     */
+    public tryParse() {
+        const strInput = this._current;
+
+        // is it an object ? a digit ? a safe number ?
+        if (!isValidString(strInput) || isDigits(strInput) || isSafeNumber(strInput)) return strInput;
+
+        let str = strInput.trim();
+
+        // the string seems to be a json object
+        if ((str.startsWith('{') && str.endsWith('}')) || (str.startsWith('[') && str.endsWith(']'))) {
+            try {
+                return JSON.parse(str);
+            } catch (e) {
+                try {
+                    const repairedJson = jsonrepair(str);
+                    return JSON.parse(repairedJson);
+                } catch (e: any) {}
+            }
+        }
+
+        // the string does not seem to be a json object, so we try to extract a json object from it
+        str = (this.extractJsonFromString(strInput) || strInput).trim();
+
+        if ((isDigits(str) && !isSafeNumber(str)) || (!str.startsWith('{') && !str.startsWith('['))) return str;
+
+        try {
+            return JSON.parse(str);
+        } catch (e) {
+            try {
+                const repairedJson = jsonrepair(str);
+                return JSON.parse(repairedJson);
+            } catch (e: any) {
+                //console.warn('Error on parseJson: ', e.toString());
+                //console.warn('   Tried to parse: ', str);
+                return strInput;
+            }
+        }
+    }
+
+    // Same as tryParse but it does not extract JSON from string
+    public tryFullParse() {
+        const str = this._current;
+        if (!str) return str;
+
+        if ((isDigits(str) && !isSafeNumber(str)) || (!str.startsWith('{') && !str.startsWith('['))) return str;
+
+        try {
+            return JSON.parse(str);
+        } catch (e) {
+            try {
+                return JSON.parse(jsonrepair(str));
+            } catch (e: any) {
+                console.warn('Error on parseJson: ', e.toString());
+                console.warn('   Tried to parse: ', str);
+                return { result: str, error: e.toString() };
+            }
+        }
+    }
+
+    private extractJsonFromString(str) {
+        try {
+            const regex = /(\{.*\})/s; // LLMs in smythOS are expected to generate json between curly brackets only
+
+            const match = str.match(regex);
+
+            return match?.[1];
+        } catch {
+            return null;
+        }
+    }
+}
+
+export function JSONContent(dataString: string) {
+    return JSONContentHelper.create(dataString);
+}

package/src/helpers/LocalCache.helper.ts

@@ -1,97 +1,97 @@
-interface CacheItem<T> {
-    value: T;
-    expiry: number;
-}
-
-export class LocalCache<K, V> {
-    private cache: Map<K, V>;
-    private expiryMap: Map<K, number>;
-    private timeouts: Map<K, NodeJS.Timeout>;
-    private defaultTTL: number = 60 * 60 * 1000;
-
-    constructor(defaultTTL: number = 60 * 60 * 1000) {
-        this.defaultTTL = defaultTTL;
-        this.cache = new Map<K, V>();
-        this.expiryMap = new Map<K, number>();
-        this.timeouts = new Map<K, NodeJS.Timeout>();
-    }
-
-    set(key: K, value: V, ttlMs: number = this.defaultTTL): void {
-        this.cache.set(key, value);
-        const expiry = Date.now() + ttlMs;
-        this.expiryMap.set(key, expiry);
-
-        // Clear any existing timeout for this key
-        this.clearTimeout(key);
-
-        // Set a new timeout to remove the item when it expires
-        const timeout = setTimeout(() => {
-            this.delete(key);
-        }, ttlMs);
-        this.timeouts.set(key, timeout);
-        timeout.unref(); //unblock the event loop
-    }
-
-    updateTTL(key: K, ttlMs: number = this.defaultTTL): void {
-        if (!this.has(key)) {
-            return;
-        }
-        const expiry = Date.now() + ttlMs;
-        this.expiryMap.set(key, expiry);
-
-        // Clear existing timeout and set a new one
-        this.clearTimeout(key);
-        const timeout = setTimeout(() => {
-            this.delete(key);
-        }, ttlMs);
-        this.timeouts.set(key, timeout);
-        timeout.unref(); //unblock the event loop
-    }
-
-    get(key: K, ttlMs?: number): V | undefined {
-        if (!this.has(key)) {
-            return undefined;
-        }
-        const value = this.cache.get(key);
-        if (value === undefined) {
-            return undefined;
-        }
-        this.updateTTL(key, ttlMs);
-        return value;
-    }
-
-    has(key: K): boolean {
-        if (!this.cache.has(key)) {
-            return false;
-        }
-        const expiry = this.expiryMap.get(key);
-        if (expiry && Date.now() > expiry) {
-            this.delete(key);
-            return false;
-        }
-        return true;
-    }
-
-    delete(key: K): boolean {
-        this.clearTimeout(key);
-        this.expiryMap.delete(key);
-        return this.cache.delete(key);
-    }
-
-    clear(): void {
-        for (const key of this.cache.keys()) {
-            this.clearTimeout(key);
-        }
-        this.cache.clear();
-        this.expiryMap.clear();
-        this.timeouts.clear();
-    }
-
-    private clearTimeout(key: K): void {
-        const timeout = this.timeouts.get(key);
-        if (timeout) {
-            clearTimeout(timeout);
-            this.timeouts.delete(key);
-        }
-    }
-}
+interface CacheItem<T> {
+    value: T;
+    expiry: number;
+}
+
+export class LocalCache<K, V> {
+    private cache: Map<K, V>;
+    private expiryMap: Map<K, number>;
+    private timeouts: Map<K, NodeJS.Timeout>;
+    private defaultTTL: number = 60 * 60 * 1000;
+
+    constructor(defaultTTL: number = 60 * 60 * 1000) {
+        this.defaultTTL = defaultTTL;
+        this.cache = new Map<K, V>();
+        this.expiryMap = new Map<K, number>();
+        this.timeouts = new Map<K, NodeJS.Timeout>();
+    }
+
+    set(key: K, value: V, ttlMs: number = this.defaultTTL): void {
+        this.cache.set(key, value);
+        const expiry = Date.now() + ttlMs;
+        this.expiryMap.set(key, expiry);
+
+        // Clear any existing timeout for this key
+        this.clearTimeout(key);
+
+        // Set a new timeout to remove the item when it expires
+        const timeout = setTimeout(() => {
+            this.delete(key);
+        }, ttlMs);
+        this.timeouts.set(key, timeout);
+        timeout.unref(); //unblock the event loop
+    }
+
+    updateTTL(key: K, ttlMs: number = this.defaultTTL): void {
+        if (!this.has(key)) {
+            return;
+        }
+        const expiry = Date.now() + ttlMs;
+        this.expiryMap.set(key, expiry);
+
+        // Clear existing timeout and set a new one
+        this.clearTimeout(key);
+        const timeout = setTimeout(() => {
+            this.delete(key);
+        }, ttlMs);
+        this.timeouts.set(key, timeout);
+        timeout.unref(); //unblock the event loop
+    }
+
+    get(key: K, ttlMs?: number): V | undefined {
+        if (!this.has(key)) {
+            return undefined;
+        }
+        const value = this.cache.get(key);
+        if (value === undefined) {
+            return undefined;
+        }
+        this.updateTTL(key, ttlMs);
+        return value;
+    }
+
+    has(key: K): boolean {
+        if (!this.cache.has(key)) {
+            return false;
+        }
+        const expiry = this.expiryMap.get(key);
+        if (expiry && Date.now() > expiry) {
+            this.delete(key);
+            return false;
+        }
+        return true;
+    }
+
+    delete(key: K): boolean {
+        this.clearTimeout(key);
+        this.expiryMap.delete(key);
+        return this.cache.delete(key);
+    }
+
+    clear(): void {
+        for (const key of this.cache.keys()) {
+            this.clearTimeout(key);
+        }
+        this.cache.clear();
+        this.expiryMap.clear();
+        this.timeouts.clear();
+    }
+
+    private clearTimeout(key: K): void {
+        const timeout = this.timeouts.get(key);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.timeouts.delete(key);
+        }
+    }
+}