@resolveio/server-lib 22.2.34 → 22.2.35

package/eslint.config.js

@@ -1,103 +0,0 @@
-const tsParser = require('@typescript-eslint/parser');
-const typescriptPlugin = require('@typescript-eslint/eslint-plugin');
-const customPlugin = require('./eslint-plugin-custom');
-const promisePlugin = require('eslint-plugin-promise');
-
-module.exports = [
-  // Base configuration for all files
-  {
-    files: ['src/**/*.ts'],
-    ignores: [
-
-    ],
-    languageOptions: {
-      parser: tsParser,
-      // You can specify your TypeScript project here if needed
-      parserOptions: { project: './tsconfig.json' },
-    },
-    plugins: {
-      '@typescript-eslint': typescriptPlugin,
-      custom: customPlugin,
-      promise: promisePlugin
-    },
-    rules: {
-      "no-unused-vars": "error",
-      // Existing rule for Math.round
-      'no-restricted-properties': [
-        'error',
-        {
-          object: 'Math',
-          property: 'round',
-          message:
-            'Please use `round` from @resolveio/server-lib instead of Math.round.',
-        },
-      ],
-      // Existing rule to restrict imports from 'moment'
-      'no-restricted-imports': [
-        'error',
-        {
-          name: 'moment',
-          message: "Please use 'moment-timezone' instead of 'moment'.",
-        },
-      ],
-      "no-restricted-syntax": [
-        "error",
-        {
-          "selector": "NewExpression[callee.name='Promise']",
-          "message": "Use async/await instead of constructing new Promise."
-        },
-        {
-          "selector": "CallExpression[callee.property.name='then']",
-          "message": "Use async/await instead of .then()"
-        },
-        {
-          "selector": "CallExpression[callee.property.name='catch']",
-          "message": "Use try/catch with async/await instead of .catch()"
-        },
-        {
-          "selector": "CallExpression[callee.property.name='forEach'] ArrowFunctionExpression AwaitExpression",
-          "message": "Don't use await inside forEach. Use for...of instead."
-        }
-      ],
-      // New rule to disallow filter(...)[0]
-     'custom/no-filter-zero-index': 'error',
-     '@typescript-eslint/no-floating-promises': [
-				'error',
-				{
-					ignoreIIFE: false, // optional
-					ignoreVoid: false  // optional
-				}
-			],
-      '@typescript-eslint/require-await': 'error',
-      "no-throw-literal": "error",
-      "@typescript-eslint/await-thenable": "error",
-      "@typescript-eslint/no-misused-promises": [
-        "error",
-        {
-          "checksVoidReturn": {
-            "attributes": false,
-            "arguments": false,
-            "properties": false
-          }
-        }
-      ],
-      "promise/prefer-await-to-then": "error"
-    }
-  },
-  {
-    files: ['src/collections/**/*.ts'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: { project: './tsconfig.json' },
-    },
-    plugins: {
-      '@typescript-eslint': typescriptPlugin,
-      custom: customPlugin,
-      promise: promisePlugin,
-    },
-    rules: {
-      '@typescript-eslint/no-floating-promises': 'off', // Only change
-      // All other rules inherit from the base config
-    },
-  },
-];

package/gulpfile.js

@@ -1,216 +0,0 @@
-var gulp = require("gulp");
-var exec = require('child_process').exec;
-var rename = require("gulp-rename");
-var del = require('del');
-var sourcemaps = require('gulp-sourcemaps');
-var zip = require('gulp-zip');
-var ts = require("gulp-typescript");
-var nodemon = require("gulp-nodemon");
-var uglify = require('gulp-uglify');
-var gulpIf = require('gulp-if');
-const { ESLint } = require('eslint');
-const fs = require('fs');
-
-
-var paths = {
-    src: 'src/**/*',
-    srcTS: 'src/**/*.ts',
-    srcPrivate: 'src/private/**/*',
-
-    tmp: 'tmp',
-    tmpJS: 'tmp/**/*.js',
-    tmpPrivate: 'tmp/private',
-
-    dist: 'dist',
-    distJS: 'dist/**/*.js',
-    distPrivate: 'dist/private',
-
-    dbDir: 'mongo/data/db',
-    dbLogs: 'mongo/log'
-};
-var shell = require('gulp-shell');
-
-gulp.task('eslint', async function () {
-    const eslint = new ESLint({
-      overrideConfigFile: './eslint.config.js'
-    });
-  
-    const results = await eslint.lintFiles(['./src/**/*.ts']);
-    const formatter = await eslint.loadFormatter('stylish');
-    const resultText = formatter.format(results);
-  
-    console.log(resultText);
-  
-    const hasErrors = results.some(result => result.errorCount > 0);
-  
-    if (hasErrors) {
-      throw new Error('ESLint errors detected');
-    }
-});
-
-gulp.task('clean', function () {
-    return del([paths.tmp, paths.dist]);
-});
-
-// Function to check if MongoDB is running and kill the process if it is
-function killMongoIfRunning(cb) {
-    exec('pgrep mongod', (err, stdout, stderr) => {
-        if (stdout) {
-            console.log('MongoDB is running. Killing the process...');
-            exec('pkill mongod', (killErr, killStdout, killStderr) => {
-                if (killErr) {
-                    console.error('Error killing MongoDB:', killStderr);
-                } else {
-                    console.log('MongoDB process killed.');
-                }
-                cb();
-            });
-        } else {
-            console.log('MongoDB is not running.');
-            cb();
-        }
-    });
-}
-
-// Gulp task to start MongoDB after killing any existing process
-gulp.task('mongo-start', function(done) {
-    killMongoIfRunning(() => {
-        fs.mkdirSync(paths.dbDir, { recursive: true });
-        fs.mkdirSync(paths.dbLogs, { recursive: true });
-
-        const finish = (() => {
-            let completed = false;
-            return (err) => {
-                if (completed) {
-                    return;
-                }
-
-                completed = true;
-                done(err);
-            };
-        })();
-
-        const stream = gulp.src('.')
-            .pipe(shell('mongod --fork --dbpath ' + paths.dbDir + '/ --logpath ' + paths.dbLogs + '/mongo.log --port 3001 --replSet rs0 --bind_ip 127.0.0.1'))
-            .pipe(shell(['mongosh --port 3001 < mongodbensurers.js']));
-
-        stream.on('error', finish);
-        stream.on('end', () => finish());
-        stream.on('finish', () => finish());
-    });
-});
-  
-gulp.task("mongo-stop", function() {
-    return gulp.src('.')
-        .pipe(shell(['killall mongod']));
-});
-
-gulp.task("config", gulp.series("clean", function() {
-    return gulp.src('./settings.development.json')
-        .pipe(rename('settings.json'))
-        .pipe(gulp.dest(paths.tmp));
-}));
-
-gulp.task("email-templates", function() {
-    return gulp.src(paths.srcPrivate)
-        .pipe(gulp.dest(paths.tmpPrivate));
-});
-
-function waitForStreams(streams) {
-	return Promise.all(streams.map((stream) => {
-		return new Promise((resolve, reject) => {
-			stream.on('finish', resolve);
-			stream.on('end', resolve);
-			stream.on('error', reject);
-		});
-	}));
-}
-
-function buildTypeScript(destination) {
-	var tsProject = ts.createProject("tsconfig.json");
-	var tsResult = gulp.src('src/**/*.ts')
-		.pipe(sourcemaps.init())
-		.pipe(tsProject());
-
-	var jsStream = tsResult.js
-		.pipe(sourcemaps.mapSources((sourcePath) => {
-			return sourcePath;
-		}))
-		.pipe(sourcemaps.write("./"))
-		.pipe(gulp.dest(destination));
-
-	var dtsStream = tsResult.dts.pipe(gulp.dest(destination));
-
-	return waitForStreams([jsStream, dtsStream]);
-}
-
-gulp.task("compile", function () {
-	return buildTypeScript(paths.tmp);
-});
-
-gulp.task('watch', function (done) {
-    gulp.watch([paths.src, './node_modules'], gulp.series('compile'));
-
-    done();
-});
-
-gulp.task("default", gulp.parallel(gulp.series("config", "email-templates", 'compile', (done) => {
-    nodemon({
-        script: "tmp/client-server-app.js",
-        watch: "tmp",
-        // exec: 'node --inspect-brk --max-old-space-size=1800 --trace-warnings',
-        exec: 'node --inspect --max-old-space-size=1800 --trace-warnings',
-        delay: 500
-    });
-
-    done();
-}), 'watch'));
-
-gulp.task("config:dist", gulp.series("clean", function() {
-	const configPath = fs.existsSync('./settings.production.json') ? './settings.production.json' : './settings.development.json';
-    return gulp.src(configPath, {allowEmpty: true})
-    .pipe(rename('settings.json'))
-    .pipe(gulp.dest(paths.dist));
-}));
-
-gulp.task("email-templates:dist", function() {
-    return gulp.src(paths.srcPrivate)
-        .pipe(gulp.dest(paths.distPrivate));
-});
-
-gulp.task("compile:dist", function () {
-	return buildTypeScript(paths.dist);
-});
-
-gulp.task("packages:dist", function () {
-    return gulp.src("./package.json")
-        .pipe(gulp.dest(paths.dist));
-});
-
-gulp.task("copy-methods-publications", function() {
-    return gulp.src(['methods.ts', 'publications.ts'])
-        .pipe(gulp.dest(paths.dist));
-});
-
-gulp.task("watch:dist", gulp.series("config:dist", "email-templates:dist", "compile:dist", "packages:dist", "copy-methods-publications", function(done) {
-	gulp.watch(paths.srcTS, gulp.series("compile:dist"));
-	gulp.watch(paths.srcPrivate, gulp.series("email-templates:dist"));
-	gulp.watch(['methods.ts', 'publications.ts'], gulp.series("copy-methods-publications"));
-	done();
-}));
-
-gulp.task("generate-methods-publications", function(done) {
-    exec('python3 methodAndPublicationListGenerator.py', function (err, stdout, stderr) {
-        if (err) {
-            console.error(`exec error: ${err}`);
-            return done(err);
-        }
-        console.log(`stdout: ${stdout}`);
-        console.error(`stderr: ${stderr}`);
-        done();
-    });
-});
-
-gulp.task("build-prod", gulp.series("eslint", "config", "email-templates:dist", "compile:dist", "packages:dist", "generate-methods-publications", "copy-methods-publications", function () {
-    return gulp.src(paths.dist + "/**/*", {dot : true});
-}));

package/methodAndPublicationListGenerator.py

@@ -1,319 +0,0 @@
-import os
-import re
-
-def parse_directory(directory, extension=".ts"):
-    files = []
-    for root, _, file_list in os.walk(directory):
-        for file in file_list:
-            if file.endswith(extension):
-                files.append(os.path.join(root, file))
-    return files
-
-def split_params(params):
-    parts = []
-    buf = ''
-    depth_paren = 0
-    depth_brace = 0
-    depth_bracket = 0
-    depth_angle = 0
-    in_single = False
-    in_double = False
-    in_template = False
-    escape = False
-
-    for ch in params:
-        if escape:
-            buf += ch
-            escape = False
-            continue
-
-        if ch == '\\' and (in_single or in_double or in_template):
-            buf += ch
-            escape = True
-            continue
-
-        if ch == "'" and not in_double and not in_template:
-            in_single = not in_single
-            buf += ch
-            continue
-
-        if ch == '"' and not in_single and not in_template:
-            in_double = not in_double
-            buf += ch
-            continue
-
-        if ch == '`' and not in_single and not in_double:
-            in_template = not in_template
-            buf += ch
-            continue
-
-        if in_single or in_double or in_template:
-            buf += ch
-            continue
-
-        if ch == '(':
-            depth_paren += 1
-        elif ch == ')':
-            depth_paren = max(0, depth_paren - 1)
-        elif ch == '{':
-            depth_brace += 1
-        elif ch == '}':
-            depth_brace = max(0, depth_brace - 1)
-        elif ch == '[':
-            depth_bracket += 1
-        elif ch == ']':
-            depth_bracket = max(0, depth_bracket - 1)
-        elif ch == '<':
-            depth_angle += 1
-        elif ch == '>':
-            depth_angle = max(0, depth_angle - 1)
-
-        if ch == ',' and depth_paren == 0 and depth_brace == 0 and depth_bracket == 0 and depth_angle == 0:
-            if buf.strip():
-                parts.append(buf.strip())
-            buf = ''
-            continue
-
-        buf += ch
-
-    if buf.strip():
-        parts.append(buf.strip())
-
-    return parts
-
-def extract_methods_from_lines(lines):
-    methods = {}
-    inside_methods_block = False
-    inside_string = False
-    method_depth = 0
-    tmp_method = None
-    types_used = set()
-
-    for line in lines:
-        line = line.strip()
-
-        if not inside_string and re.search(r'(\.methods\(\s*\{)', line):
-            inside_methods_block = True
-            method_depth = 1
-            continue
-
-        if not inside_methods_block:
-            continue
-
-        inside_string = not inside_string if re.search(r'(?<!\\)(\'|")', line) else inside_string
-
-        method_depth += line.count('{') - line.count('}')
-
-        if method_depth == 2 and re.match(r'^[a-zA-Z0-9_]+:\s*\{', line):
-            tmp_method = re.match(r'^([a-zA-Z0-9_]+):\s*\{', line).group(1)
-
-        if tmp_method and method_depth == 3 and (re.search(r'function:\s*function\s*\(', line) or re.search(r'function:\s*async\s*function\s*\(', line)):
-            function_match = re.search(r'function\s*\(([^)]*)\)', line)
-
-            if function_match:
-                params = function_match.group(1).strip()
-                param_list = []
-                call_params = []
-                for param in split_params(params):
-                    param_parts = param.split(':', 1)
-                    param_name = param_parts[0].strip().replace('?', '').split('=')[0].strip()
-                    param_type = param_parts[1].strip() if len(param_parts) > 1 else ''
-
-                    # Handle arrays or other complex types
-                    base_type = re.sub(r'\[\]|\<.*?\>', '', param_type).strip()
-                    if base_type:
-                        types_used.add(base_type)
-                    param_list.append(param.strip())
-                    call_params.append(param_name)
-
-                tmp_parameters = ", ".join(param_list)
-
-                if tmp_parameters:
-                    method_line = f"\t\t{tmp_method}: ({tmp_parameters}, cb?: Function): Promise<any> => {{"
-                    call_line = f"\t\t\treturn resolveioServer.call('{tmp_method}', {', '.join(call_params)}, cb);"
-                else:
-                    method_line = f"\t\t{tmp_method}: (cb?: Function): Promise<any> => {{"
-                    call_line = f"\t\t\treturn resolveioServer.call('{tmp_method}', cb);"
-                
-                methods[tmp_method] = [method_line, call_line, "\t\t},"]
-            tmp_method = None
-
-        if method_depth == 0 and '});' in line:
-            inside_methods_block = False
-
-    return methods, types_used
-
-def extract_publications_from_lines(lines):
-    publications = {}
-    inside_publications_block = False
-    inside_string = False
-    publication_depth = 0
-    tmp_publication = None
-    types_used = set()
-
-    for line in lines:
-        line = line.strip()
-
-        if not inside_string and re.search(r'(\.publications\(\s*\{)', line):
-            inside_publications_block = True
-            publication_depth = 1
-            continue
-
-        if not inside_publications_block:
-            continue
-
-        inside_string = not inside_string if re.search(r'(?<!\\)(\'|")', line) else inside_string
-
-        publication_depth += line.count('{') - line.count('}')
-
-        if publication_depth == 2 and re.match(r'^[a-zA-Z0-9_]+:\s*\{', line):
-            tmp_publication = re.match(r'^([a-zA-Z0-9_]+):\s*\{', line).group(1)
-
-        if tmp_publication and publication_depth == 3 and (re.search(r'function:\s*function\s*\(', line) or re.search(r'function:\s*async\s*function\s*\(', line)):
-            function_match = re.search(r'function\s*\(([^)]*)\)', line)
-
-            if function_match:
-                params = function_match.group(1).strip()
-                param_list = []
-                call_params = []
-                for param in split_params(params):
-                    param_parts = param.split(':', 1)
-                    param_name = param_parts[0].strip().replace('?', '').split('=')[0].strip()
-                    param_type = param_parts[1].strip() if len(param_parts) > 1 else ''
-                    
-                    # Handle arrays or other complex types
-                    base_type = re.sub(r'\[\]|\<.*?\>', '', param_type).strip()
-                    if base_type:
-                        types_used.add(base_type)
-                    param_list.append(param.strip())
-                    call_params.append(param_name)
-
-
-                tmp_parameters = ", ".join(param_list)
-
-                if tmp_parameters:
-                    publication_line = f"\t\t{tmp_publication}: ({tmp_parameters}) => {{"
-                    call_line = f"\t\t\treturn <Observable<any>> resolveioServer.subscribe('{tmp_publication}', {', '.join(call_params)});"
-                else:
-                    publication_line = f"\t\t{tmp_publication}: () => {{"
-                    call_line = f"\t\t\treturn <Observable<any>> resolveioServer.subscribe('{tmp_publication}');"
-
-                publications[tmp_publication] = [publication_line, call_line, "\t\t},"]
-                
-            tmp_publication = None
-
-        if publication_depth == 0 and '});' in line:
-            inside_publications_block = False
-
-    return publications, types_used
-
-def generate_import_statements(types_used, models_directory):
-    import_statements = []
-    available_models = {}
-
-    # Scan the models directory to find available models and types
-    for root, _, files in os.walk(models_directory):
-        for file in files:
-            if file.endswith(".ts"):
-                file_path = os.path.join(root, file)
-                with open(file_path, 'r') as model_file:
-                    model_content = model_file.read()
-
-                    # Look for both interface and type exports
-                    export_matches = re.findall(r'export\s+(?:interface|type)\s+([a-zA-Z0-9_]+)', model_content)
-                    for match in export_matches:
-                        available_models[match] = os.path.relpath(file_path, start=os.path.dirname(models_directory)).replace("\\", "/").replace(".ts", "")
-
-    # Generate import statements for types used
-    for type_name in types_used:
-        if type_name in available_models:
-            import_path = available_models[type_name]
-            import_statements.append(f"import {{ {type_name} }} from './{import_path}';")
-
-    return sorted(import_statements)
-
-def generate_methods_file(files, models_directory, output_file):
-    method_blocks = {}  # Dictionary to hold method blocks
-    all_types_used = set()  # Set to track types used
-
-    # Iterate over each file and extract methods
-    for file in files:
-        with open(file, 'r') as f:
-            lines = f.readlines()
-            extracted_methods, types_used = extract_methods_from_lines(lines)
-
-            # Collect all method blocks from this file into method_blocks
-            method_blocks.update(extracted_methods)
-
-            # Collect types used
-            all_types_used.update(types_used)
-
-    # Sort methods globally by their method names
-    sorted_method_names = sorted(method_blocks.keys())
-
-    # Generate import statements
-    import_statements = generate_import_statements(all_types_used, models_directory)
-
-    # Write to the output file
-    with open(output_file, 'w') as f:
-        for import_statement in import_statements:
-            f.write(f"{import_statement}\n")
-        f.write("\nexport function SERVER_METHODS(resolveioServer) {\n")
-        f.write("\treturn {\n")
-
-        # Append sorted methods to the file
-        for method_name in sorted_method_names:
-            for line in method_blocks[method_name]:
-                f.write(f"{line}\n")
-
-        f.write("\t};\n")
-        f.write("}\n")
-
-def generate_publications_file(files, models_directory, output_file):
-    publication_blocks = {}  # Dictionary to hold publication blocks
-    all_types_used = set()  # Set to track types used
-
-    # Iterate over each file and extract publications
-    for file in files:
-        with open(file, 'r') as f:
-            lines = f.readlines()
-            extracted_publications, types_used = extract_publications_from_lines(lines)
-
-            # Collect all method blocks from this file into method_blocks
-            publication_blocks.update(extracted_publications)
-
-            # Collect types used
-            all_types_used.update(types_used)
-
-    # Sort publications globally by their publication names
-    sorted_publication_names = sorted(publication_blocks.keys())
-
-    # Generate import statements
-    import_statements = generate_import_statements(all_types_used, models_directory)
-
-    # Write to the output file
-    with open(output_file, 'w') as f:
-        f.write("import { Observable } from 'rxjs';\n")
-        for import_statement in import_statements:
-            f.write(f"{import_statement}\n")
-        f.write("\nexport function SERVER_PUBLICATIONS(resolveioServer) {\n")
-        f.write("\treturn {\n")
-
-        # Append sorted publications to the file
-        for publication_name in sorted_publication_names:
-            for line in publication_blocks[publication_name]:
-                f.write(f"{line}\n")
-
-        f.write("\t};\n")
-        f.write("}\n")
-
-if __name__ == "__main__":
-    method_dir = './src/methods'
-    pub_dir = './src/publications'
-    models_dir = './src/models'
-    
-    method_files = parse_directory(method_dir)
-    pub_files = parse_directory(pub_dir)
-    
-    generate_methods_file(method_files, models_dir, 'methods.ts')
-    generate_publications_file(pub_files, models_dir, 'publications.ts')

package/mongodbensurers.js

@@ -1,2 +0,0 @@
-rs.initiate();
-exit;

package/mongostop.js

@@ -1,3 +0,0 @@
-db.adminCommand( { replSetStepDown: 120, secondaryCatchUpPeriodSecs: 15, force: true } );
-db.shutdownServer();
-exit;

package/settings.development.json

@@ -1,25 +0,0 @@
-{
-    "CLIENT_NAME": "ResolveIO",
-    "DATABASE": "resolveio",
-    "MONGO_URL": "mongodb://127.0.0.1:3001/resolveio",
-    "OPLOG_URL": "mongodb://127.0.0.1:3001/local",
-    "MAIL_URL": "smtps://AKIAISVPD3SREQHE523Q:Ar3qzozs3JFxu00Uw94FBatPKJydEZeBBvdqmpniVSt6@email-smtp.us-east-1.amazonaws.com:465/",
-    "MAIL_FROM": "dev@resolveio.com",
-    "ROOT_URL": "http://localhost:4200",
-    "SERVER_URL": "http://localhost:8080",
-    "SEC_ROOT_URL": "http://localhost:8081",
-    "CLOUDCONVERT": "YiMz1FUvcqrAOnFGbkcKkBbjQw8LmgNz6tGoCvUCuwgHFmDv2XyiEYrOrDJvF7S6CWbCP_RgjhyeFvVMNOVIwQ",
-    "CLOUDCONVERT_V2": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJhdWQiOiIxIiwianRpIjoiMzcxYzQ2OTE5NjhhOTMxZTc1NTUxNmJiZWRlNmFkOWNhMDMxNGM4ZTU2NmJiNzVlODgwODE1MzljYTk2ZjQ4ZGRhMzU1Yzg4OGQ3ZmZhMWQiLCJpYXQiOjE2MDIyNTg4MDAsIm5iZiI6MTYwMjI1ODgwMCwiZXhwIjo0NzU3OTMyNDAwLCJzdWIiOiIyNzM3OTU2NSIsInNjb3BlcyI6WyJ1c2VyLnJlYWQiLCJ1c2VyLndyaXRlIiwidGFzay5yZWFkIiwidGFzay53cml0ZSIsIndlYmhvb2sucmVhZCIsIndlYmhvb2sud3JpdGUiLCJwcmVzZXQucmVhZCIsInByZXNldC53cml0ZSJdfQ.eD8Tkxmo0HGHkhaeUtIFezdNUvpd0R6exPej-TB3xafY6QlMJzlb2y48JNe4oCikQfOR_0bvOyVexo5-aSaetjl_7nmkgbxwRrlyo9FJFI9k4ERB1daoIH-lIKpW5j5zqm0kU1Gps2y-az7FS1FcB3MAOAMcEXPATWouaSPTSgn9AG9MNNBnLZqO13V7whqjJsCeIwuWxZ5G4a4Nvmlu0WsqEHZtGbkwKRwtZ4a8-zanVw8SED4O2i9PeV4h8dG6Pt0MfBsfGvwSkfPif8eMAHs4elqVLvWUl_oY3-pe_WlG2RKLP5fpVPeyUaT3bRTuwgsi2T-E54fBEXpFcUBjmulB5ihJQwde7RZcGRcg5t5sz0NDlYYr0tyB69GXXku9ayHCiT5qm0F2yAGZV6_K_SXM9_Sjd5a4Nk9HHpSGRfHGoCrhNZFnb1R-y2zbsD4QG3KQLVbsNm7W410_NQEusrCejwcjDUnd3fNlw77-dwPQ_hALKzV-JBl9dVAE_67ONsvweuJHkMsfFyly7rryUh9JRWREAPGXDWJOlnSrzAKmQyTpLyOY-jMj8q2_1lClSauOQn2eqCL45ccDaz_xXGCdDg9QFYfN6Nc8NjkoTShCBG1oFz4UdpEkGptPOviDGelu4u_Fwv_-srh7l1QzFv_2YRpJkzjNw8-vA46h0RQ",
-    "TWILIO_SID": "AC6338adffd405964cf4d2cf0af59abd2e",
-    "TWILIO_AUTH_TOKEN": "8ae1086fff332e069f0b3582e6dafc72",
-    "TWILIO_PHONE_NUMBER": "+18777937285",
-    "JWT_SECRET": "tr3dkmoXWcWGAUxywETXqkpb",
-    "DEBUG_EMAIL": "dev@resolveio.com",
-    "GOOGLE_API_KEY": "AIzaSyCeB_KqVONHrB8e6F6d8LTqhMDCK0GAxqY",
-    "AI_ASSISTANT_CODEX_PLANNER_ENABLED": true,
-    "AI_ASSISTANT_FAST_MODE_ENABLED": false,
-    "AI_ASSISTANT_ALWAYS_ALLOW_PROBE": true,
-    "AI_ASSISTANT_RUN_BUDGET_MS": 120000,
-    "AI_ASSISTANT_MONGO_MAX_TIME_MS": 12000,
-    "AI_ASSISTANT_CODEX_TIMEOUT_MS": 180000
-}