@resolveio/server-lib 22.3.220 → 22.3.221

package/scripts/cleanup-bypassed-callmethod-logs.js

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { MongoClient } = require('mongodb');
+
+const DEFAULT_DB_NAME = 'resolveio';
+const DEFAULT_COLLECTION_NAME = 'logs';
+const DEFAULT_BATCH_SIZE = 200;
+const DEFAULT_SLEEP_MS = 1000;
+
+function parseArgs(argv) {
+	const options = {
+		uri: process.env.MONGO_URL || '',
+		dbName: process.env.MONGO_DB || DEFAULT_DB_NAME,
+		collectionName: DEFAULT_COLLECTION_NAME,
+		batchSize: DEFAULT_BATCH_SIZE,
+		sleepMs: DEFAULT_SLEEP_MS,
+		execute: false,
+		includeAmbiguous: false,
+		maxBatches: 0,
+		maxDeletes: 0,
+		methods: [],
+		settingsPath: '',
+		createdBefore: '',
+		createdAfter: '',
+		listOnly: false
+	};
+
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		const next = argv[i + 1];
+
+		if (arg === '--uri' && next) {
+			options.uri = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--uri=')) {
+			options.uri = arg.slice('--uri='.length);
+			continue;
+		}
+		if (arg === '--db' && next) {
+			options.dbName = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--db=')) {
+			options.dbName = arg.slice('--db='.length);
+			continue;
+		}
+		if (arg === '--collection' && next) {
+			options.collectionName = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--collection=')) {
+			options.collectionName = arg.slice('--collection='.length);
+			continue;
+		}
+		if (arg === '--batch-size' && next) {
+			options.batchSize = Number(next) || DEFAULT_BATCH_SIZE;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--batch-size=')) {
+			options.batchSize = Number(arg.slice('--batch-size='.length)) || DEFAULT_BATCH_SIZE;
+			continue;
+		}
+		if (arg === '--sleep-ms' && next) {
+			options.sleepMs = Number(next) || DEFAULT_SLEEP_MS;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--sleep-ms=')) {
+			options.sleepMs = Number(arg.slice('--sleep-ms='.length)) || DEFAULT_SLEEP_MS;
+			continue;
+		}
+		if (arg === '--max-batches' && next) {
+			options.maxBatches = Number(next) || 0;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--max-batches=')) {
+			options.maxBatches = Number(arg.slice('--max-batches='.length)) || 0;
+			continue;
+		}
+		if (arg === '--max-deletes' && next) {
+			options.maxDeletes = Number(next) || 0;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--max-deletes=')) {
+			options.maxDeletes = Number(arg.slice('--max-deletes='.length)) || 0;
+			continue;
+		}
+		if (arg === '--methods' && next) {
+			options.methods = next.split(',').map(value => value.trim()).filter(Boolean);
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--methods=')) {
+			options.methods = arg.slice('--methods='.length).split(',').map(value => value.trim()).filter(Boolean);
+			continue;
+		}
+		if (arg === '--settings' && next) {
+			options.settingsPath = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--settings=')) {
+			options.settingsPath = arg.slice('--settings='.length);
+			continue;
+		}
+		if (arg === '--created-before' && next) {
+			options.createdBefore = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--created-before=')) {
+			options.createdBefore = arg.slice('--created-before='.length);
+			continue;
+		}
+		if (arg === '--created-after' && next) {
+			options.createdAfter = next;
+			i += 1;
+			continue;
+		}
+		if (arg.startsWith('--created-after=')) {
+			options.createdAfter = arg.slice('--created-after='.length);
+			continue;
+		}
+		if (arg === '--execute') {
+			options.execute = true;
+			continue;
+		}
+		if (arg === '--include-ambiguous') {
+			options.includeAmbiguous = true;
+			continue;
+		}
+		if (arg === '--list-only') {
+			options.listOnly = true;
+			continue;
+		}
+		if (arg === '--help' || arg === '-h') {
+			printUsage();
+			process.exit(0);
+		}
+	}
+
+	return options;
+}
+
+function printUsage() {
+	console.log(`
+Usage:
+  node scripts/cleanup-bypassed-callmethod-logs.js [options]
+
+Options:
+  --settings <path>         Read Mongo connection info from a settings JSON file
+  --uri <mongodb-uri>       MongoDB connection string
+  --db <name>               Database name, default: ${DEFAULT_DB_NAME}
+  --collection <name>       Collection name, default: ${DEFAULT_COLLECTION_NAME}
+  --batch-size <n>          Docs to delete per batch, default: ${DEFAULT_BATCH_SIZE}
+  --sleep-ms <n>            Delay between delete batches, default: ${DEFAULT_SLEEP_MS}
+  --max-batches <n>         Stop after this many delete batches, default: unlimited
+  --max-deletes <n>         Stop after this many deleted docs, default: unlimited
+  --methods a,b,c           Override the discovered method list
+  --created-after <iso>     Only target docs on or after this createdAt timestamp
+  --created-before <iso>    Only target docs before this createdAt timestamp
+  --include-ambiguous       Also include method names that are bypassed in some apps but not others
+  --execute                 Actually delete docs. Without this, the script only previews.
+  --list-only               Only print discovered method names and exit
+
+Examples:
+  node scripts/cleanup-bypassed-callmethod-logs.js --settings /var/app/current/settings.json
+  node scripts/cleanup-bypassed-callmethod-logs.js --settings /var/app/current/settings.json --execute --batch-size 100 --sleep-ms 2000
+  node scripts/cleanup-bypassed-callmethod-logs.js --uri mongodb://... --execute --max-deletes 5000
+`.trim());
+}
+
+function normalizeMethodName(rawName) {
+	return rawName.replace(/^['"]|['"]$/g, '');
+}
+
+function countBraceDelta(line) {
+	let delta = 0;
+	let inSingle = false;
+	let inDouble = false;
+	let inTemplate = false;
+	let escaped = false;
+
+	for (const char of line) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (char === '\\') {
+			escaped = true;
+			continue;
+		}
+
+		if (!inDouble && !inTemplate && char === '\'') {
+			inSingle = !inSingle;
+			continue;
+		}
+		if (!inSingle && !inTemplate && char === '"') {
+			inDouble = !inDouble;
+			continue;
+		}
+		if (!inSingle && !inDouble && char === '`') {
+			inTemplate = !inTemplate;
+			continue;
+		}
+
+		if (inSingle || inDouble || inTemplate) {
+			continue;
+		}
+
+		if (char === '{') {
+			delta += 1;
+		}
+		else if (char === '}') {
+			delta -= 1;
+		}
+	}
+
+	return delta;
+}
+
+function collectFiles(dirPath, result = []) {
+	if (!fs.existsSync(dirPath)) {
+		return result;
+	}
+
+	const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
+			continue;
+		}
+
+		const fullPath = path.join(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			collectFiles(fullPath, result);
+			continue;
+		}
+
+		if (!entry.isFile() || !fullPath.endsWith('.ts')) {
+			continue;
+		}
+
+		if (
+			fullPath.includes(`${path.sep}src${path.sep}methods${path.sep}`)
+			|| fullPath.includes(`${path.sep}server${path.sep}src${path.sep}methods${path.sep}`)
+			|| fullPath.includes(`${path.sep}server${path.sep}src${path.sep}qb${path.sep}methods${path.sep}`)
+		) {
+			result.push(fullPath);
+		}
+	}
+
+	return result;
+}
+
+function extractMethodDefinitions(filePath) {
+	const content = fs.readFileSync(filePath, 'utf8');
+	const lines = content.split(/\r?\n/);
+	const definitions = [];
+
+	let inMethodsCall = false;
+	let methodsDepth = 0;
+	let currentMethod = null;
+
+	for (const line of lines) {
+		if (!inMethodsCall && line.includes('methods({')) {
+			inMethodsCall = true;
+			methodsDepth = 1;
+			currentMethod = null;
+			continue;
+		}
+
+		if (!inMethodsCall) {
+			continue;
+		}
+
+		const methodStartMatch = !currentMethod && methodsDepth === 1
+			? line.match(/^\s*(['"]?[A-Za-z0-9_-]+['"]?)\s*:\s*{\s*$/)
+			: null;
+
+		if (methodStartMatch) {
+			currentMethod = {
+				name: normalizeMethodName(methodStartMatch[1]),
+				filePath,
+				bypass: false,
+				depth: 0
+			};
+		}
+
+		if (currentMethod && /bypassLogs?\s*:\s*true\b/.test(line)) {
+			currentMethod.bypass = true;
+		}
+
+		const braceDelta = countBraceDelta(line);
+		methodsDepth += braceDelta;
+
+		if (currentMethod) {
+			currentMethod.depth += braceDelta;
+			if (currentMethod.depth === 0) {
+				definitions.push({
+					name: currentMethod.name,
+					filePath: currentMethod.filePath,
+					bypass: currentMethod.bypass
+				});
+				currentMethod = null;
+			}
+		}
+
+		if (methodsDepth === 0) {
+			inMethodsCall = false;
+			currentMethod = null;
+		}
+	}
+
+	return definitions;
+}
+
+function collectMethodDirectories(workspaceRoot) {
+	const directories = [
+		path.join(workspaceRoot, 'resolveio-server-lib', 'src', 'methods'),
+		path.join(workspaceRoot, 'snf', 'snf', 'server', 'src', 'methods')
+	];
+
+	const multiAppRoots = [
+		path.join(workspaceRoot, 'resolveio-all'),
+		path.join(workspaceRoot, 'resolveio-crypto')
+	];
+
+	for (const appsRoot of multiAppRoots) {
+		if (!fs.existsSync(appsRoot)) {
+			continue;
+		}
+
+		const appEntries = fs.readdirSync(appsRoot, { withFileTypes: true });
+		for (const appEntry of appEntries) {
+			if (!appEntry.isDirectory()) {
+				continue;
+			}
+
+			const appRoot = path.join(appsRoot, appEntry.name);
+			const methodDir = path.join(appRoot, 'server', 'src', 'methods');
+			const qbMethodDir = path.join(appRoot, 'server', 'src', 'qb', 'methods');
+
+			if (fs.existsSync(methodDir)) {
+				directories.push(methodDir);
+			}
+			if (fs.existsSync(qbMethodDir)) {
+				directories.push(qbMethodDir);
+			}
+		}
+	}
+
+	return directories;
+}
+
+function discoverBypassedMethods(workspaceRoot) {
+	const scanRoots = collectMethodDirectories(workspaceRoot);
+
+	const allDefinitions = [];
+	for (const root of scanRoots) {
+		const files = collectFiles(root);
+		for (const filePath of files) {
+			allDefinitions.push(...extractMethodDefinitions(filePath));
+		}
+	}
+
+	const grouped = new Map();
+	for (const definition of allDefinitions) {
+		if (!grouped.has(definition.name)) {
+			grouped.set(definition.name, []);
+		}
+		grouped.get(definition.name).push(definition);
+	}
+
+	const safeMethods = [];
+	const ambiguousMethods = [];
+
+	for (const [methodName, definitions] of grouped.entries()) {
+		const bypassed = definitions.filter(definition => definition.bypass);
+		if (!bypassed.length) {
+			continue;
+		}
+
+		const nonBypassed = definitions.filter(definition => !definition.bypass);
+		if (nonBypassed.length) {
+			ambiguousMethods.push({
+				method: methodName,
+				bypassedFiles: bypassed.map(definition => definition.filePath),
+				nonBypassedFiles: nonBypassed.map(definition => definition.filePath)
+			});
+			continue;
+		}
+
+		safeMethods.push(methodName);
+	}
+
+	safeMethods.sort((a, b) => a.localeCompare(b));
+	ambiguousMethods.sort((a, b) => a.method.localeCompare(b.method));
+
+	return {
+		safeMethods,
+		ambiguousMethods
+	};
+}
+
+function readSettingsFile(settingsPath) {
+	const raw = fs.readFileSync(settingsPath, 'utf8');
+	const parsed = JSON.parse(raw);
+
+	const candidateValues = [
+		parsed?.custom_env?.MONGO_URL,
+		parsed?.custom_env?.mongo_url,
+		parsed?.MONGO_URL,
+		parsed?.mongo_url,
+		parsed?.env?.MONGO_URL
+	].filter(Boolean);
+
+	const uri = candidateValues.find(value => typeof value === 'string' && value.trim());
+	if (!uri) {
+		throw new Error(`Could not find MONGO_URL in settings file: ${settingsPath}`);
+	}
+
+	return uri.trim();
+}
+
+function parseOptionalDate(value, label) {
+	if (!value) {
+		return undefined;
+	}
+
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime())) {
+		throw new Error(`Invalid ${label}: ${value}`);
+	}
+
+	return parsed;
+}
+
+function sleep(ms) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function formatMethodCounts(docs) {
+	const counts = docs.reduce((accumulator, doc) => {
+		accumulator[doc.method] = (accumulator[doc.method] || 0) + 1;
+		return accumulator;
+	}, {});
+
+	return Object.entries(counts)
+		.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+		.map(([method, count]) => `${method}:${count}`)
+		.join(', ');
+}
+
+async function previewBatch(logsCollection, filter, batchSize) {
+	const cursor = logsCollection.find(filter, {
+		projection: { _id: 1, method: 1, createdAt: 1 }
+	}).sort({ createdAt: 1 }).hint({ createdAt: 1 }).limit(batchSize);
+
+	return await cursor.toArray();
+}
+
+async function run() {
+	const options = parseArgs(process.argv.slice(2));
+	const workspaceRoot = path.resolve(__dirname, '..', '..');
+	const discovery = discoverBypassedMethods(workspaceRoot);
+
+	if (!options.uri && options.settingsPath) {
+		options.uri = readSettingsFile(options.settingsPath);
+	}
+
+	const selectedMethods = options.methods.length
+		? [...new Set(options.methods)].sort((a, b) => a.localeCompare(b))
+		: [
+			...discovery.safeMethods,
+			...(options.includeAmbiguous ? discovery.ambiguousMethods.map(item => item.method) : [])
+		];
+
+	console.log(`Discovered safe bypassed methods: ${discovery.safeMethods.length}`);
+	console.log(discovery.safeMethods.join(', ') || '[none]');
+
+	if (discovery.ambiguousMethods.length) {
+		console.log('');
+		console.log(`Skipped ambiguous method names by default: ${discovery.ambiguousMethods.length}`);
+		for (const ambiguous of discovery.ambiguousMethods) {
+			console.log(`- ${ambiguous.method}`);
+			console.log(`  bypassed: ${ambiguous.bypassedFiles.join(', ')}`);
+			console.log(`  non-bypassed: ${ambiguous.nonBypassedFiles.join(', ')}`);
+		}
+	}
+
+	if (options.listOnly) {
+		return;
+	}
+
+	if (!selectedMethods.length) {
+		console.log('');
+		console.log('No target methods selected.');
+		return;
+	}
+
+	console.log('');
+	console.log(`Target methods (${selectedMethods.length}): ${selectedMethods.join(', ')}`);
+
+	if (!options.uri) {
+		console.log('');
+		console.log('No Mongo URI provided. Use --uri or --settings to query or delete logs.');
+		return;
+	}
+
+	const createdAfter = parseOptionalDate(options.createdAfter, 'created-after');
+	const createdBefore = parseOptionalDate(options.createdBefore, 'created-before');
+
+	const filter = {
+		type: 'callMethod',
+		method: { $in: selectedMethods }
+	};
+
+	if (createdAfter || createdBefore) {
+		filter.createdAt = {};
+		if (createdAfter) {
+			filter.createdAt.$gte = createdAfter;
+		}
+		if (createdBefore) {
+			filter.createdAt.$lt = createdBefore;
+		}
+	}
+
+	const client = new MongoClient(options.uri, {
+		maxPoolSize: 5,
+		retryWrites: true
+	});
+
+	let deletedCount = 0;
+	let batches = 0;
+
+	try {
+		await client.connect();
+		const db = client.db(options.dbName);
+		const logsCollection = db.collection(options.collectionName);
+
+		const previewDocs = await previewBatch(logsCollection, filter, Math.min(options.batchSize, 25));
+		console.log('');
+		console.log(`Preview candidates: ${previewDocs.length}`);
+		if (previewDocs.length) {
+			console.log(`Preview batch methods: ${formatMethodCounts(previewDocs)}`);
+			console.log(`Preview createdAt range: ${previewDocs[0].createdAt?.toISOString?.() || previewDocs[0].createdAt} -> ${previewDocs[previewDocs.length - 1].createdAt?.toISOString?.() || previewDocs[previewDocs.length - 1].createdAt}`);
+		}
+
+		if (!options.execute) {
+			console.log('');
+			console.log('Dry run only. Re-run with --execute to delete documents.');
+			return;
+		}
+
+		console.log('');
+		console.log(`Deleting from ${options.dbName}.${options.collectionName} with batchSize=${options.batchSize}, sleepMs=${options.sleepMs}`);
+
+		while (true) {
+			if (options.maxBatches > 0 && batches >= options.maxBatches) {
+				console.log(`Reached max batches: ${options.maxBatches}`);
+				break;
+			}
+			if (options.maxDeletes > 0 && deletedCount >= options.maxDeletes) {
+				console.log(`Reached max deletes: ${options.maxDeletes}`);
+				break;
+			}
+
+			const batchDocs = await previewBatch(logsCollection, filter, options.batchSize);
+			if (!batchDocs.length) {
+				console.log('No more matching documents found.');
+				break;
+			}
+
+			const batchIds = batchDocs.map(doc => doc._id);
+			const batchSummary = formatMethodCounts(batchDocs);
+			const firstCreatedAt = batchDocs[0].createdAt?.toISOString?.() || batchDocs[0].createdAt;
+			const lastCreatedAt = batchDocs[batchDocs.length - 1].createdAt?.toISOString?.() || batchDocs[batchDocs.length - 1].createdAt;
+
+			const deleteResult = await logsCollection.deleteMany({
+				_id: { $in: batchIds }
+			});
+
+			batches += 1;
+			deletedCount += deleteResult.deletedCount || 0;
+
+			console.log(`Batch ${batches}: deleted ${deleteResult.deletedCount || 0} docs, total ${deletedCount}, range ${firstCreatedAt} -> ${lastCreatedAt}, methods ${batchSummary}`);
+
+			if ((deleteResult.deletedCount || 0) === 0) {
+				console.log('Delete returned 0 docs. Stopping to avoid a tight loop.');
+				break;
+			}
+
+			if (options.sleepMs > 0) {
+				await sleep(options.sleepMs);
+			}
+		}
+	}
+	finally {
+		await client.close();
+	}
+}
+
+run().catch((error) => {
+	console.error(error && error.stack ? error.stack : error);
+	process.exit(1);
+});

package/settings.development.json

@@ -0,0 +1,25 @@
+{
+    "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
+}

package/settings.development.redacted.json

@@ -0,0 +1,25 @@
+{
+    "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": "<REDACTED>",
+    "MAIL_FROM": "<REDACTED>",
+    "ROOT_URL": "http://localhost:4200",
+    "SERVER_URL": "http://localhost:8080",
+    "SEC_ROOT_URL": "http://localhost:8081",
+    "CLOUDCONVERT": "<REDACTED>",
+    "CLOUDCONVERT_V2": "<REDACTED>",
+    "TWILIO_SID": "<REDACTED>",
+    "TWILIO_AUTH_TOKEN": "<REDACTED>",
+    "TWILIO_PHONE_NUMBER": "<REDACTED>",
+    "JWT_SECRET": "<REDACTED>",
+    "DEBUG_EMAIL": "<REDACTED>",
+    "GOOGLE_API_KEY": "<REDACTED>",
+    "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
+}

package/src/.env

@@ -0,0 +1,12 @@
+PORT=8081
+NPM_TOKEN=5f4981ed-c21d-4648-81cf-4cbbd1c53abe
+TZ=UTC
+TZ_CLIENT=America/Chicago
+AWS_ACCESS_KEY=AKIAJOTKSHQB4QNL7AXA
+AWS_SECRET_ACCESS_KEY=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
+AWS_REGION=us-west-2
+AWS_SES_REGION=us-east-1
+AWS_S3_BUCKET=dpinventorypo
+PM2_KILL_TIMEOUT=10000
+IS_WORKERS_ENABLED=false
+IS_WORKER_INSTANCE=false