@resolveio/server-lib 22.1.18 → 22.1.20

package/methods/mongo-explorer.js

@@ -35,14 +35,62 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMongoExplorerMethods = loadMongoExplorerMethods;
 var simpl_schema_1 = require("simpl-schema");
 var user_collection_1 = require("../collections/user.collection");
 var resolveio_server_app_1 = require("../resolveio-server-app");
+var openai_client_1 = require("../services/openai-client");
 var common_1 = require("../util/common");
 var DEFAULT_LIMIT = 100;
 var MAX_LIMIT = 2000;
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+var MAX_REVIEW_STRING_LENGTH = 500;
+var MAX_REVIEW_ARRAY_ITEMS = 10;
+var MAX_REVIEW_OBJECT_KEYS = 40;
+var MAX_REVIEW_DEPTH = 4;
+var MAX_REVIEW_LIST_ITEMS = 6;
+var MAX_REVIEW_CHANGED_FIELDS = 60;
+var DEFAULT_RISK_REVIEW_TIMEOUT_MS = 30000;
+var DEFAULT_RISK_REVIEW_MAX_TOKENS = 700;
+var DEFAULT_RISK_REVIEW_MODEL = 'gpt-5.3-codex';
+var SENSITIVE_REVIEW_FIELD_REGEX = /(password|secret|token|api[_-]?key|salt|hash|email|phone|address|ssn|services|roles)/i;
 function parseMongoExplorerWriteUsers() {
     var raw = typeof process.env.MONGO_EXPLORER_WRITE_USERS === 'string' ? process.env.MONGO_EXPLORER_WRITE_USERS.trim() : '';
     if (!raw) {
@@ -65,6 +113,24 @@ function parseMongoExplorerWriteUsers() {
         .map(function (value) { return value.trim(); })
         .filter(Boolean);
 }
+function normalizeExplorerMode(mode) {
+    var normalizedMode = String(mode || '').trim().toLowerCase();
+    if (normalizedMode === 'resolveio') {
+        return 'resolveio';
+    }
+    return 'aicoder';
+}
+function isAdminUser(user) {
+    var _a;
+    if (!user) {
+        return false;
+    }
+    var username = String(user.username || '').trim().toLowerCase();
+    return username === 'admin' || ((_a = user.roles) === null || _a === void 0 ? void 0 : _a.super_admin) === true;
+}
+function allowUnschemaizedWrites() {
+    return process.env.MONGO_EXPLORER_ALLOW_UNSCHEMATIZED_WRITE === 'true';
+}
 function resolveDatabaseName(database) {
     var _a, _b;
     var defaultDb = ((_a = resolveio_server_app_1.ResolveIOServer.getServerConfig()) === null || _a === void 0 ? void 0 : _a.DATABASE) || '';
@@ -93,6 +159,172 @@ function resolveCollectionHandle(database, collection) {
         dbCollection: db.collection(collection)
     };
 }
+function getSchemaDefinition(collectionRef) {
+    if (!collectionRef || !collectionRef.simplschema || typeof collectionRef.simplschema.schema !== 'function') {
+        return {};
+    }
+    var schema = collectionRef.simplschema.schema();
+    return schema && typeof schema === 'object' ? schema : {};
+}
+function getSchemaTypeName(definition) {
+    var _a, _b;
+    var typeDefs = (_a = definition === null || definition === void 0 ? void 0 : definition.type) === null || _a === void 0 ? void 0 : _a.definitions;
+    if (!Array.isArray(typeDefs) || !typeDefs.length) {
+        return 'Any';
+    }
+    var firstType = (_b = typeDefs[0]) === null || _b === void 0 ? void 0 : _b.type;
+    if (!firstType) {
+        return 'Any';
+    }
+    if (firstType === String) {
+        return 'String';
+    }
+    if (firstType === Number) {
+        return 'Number';
+    }
+    if (firstType === Boolean) {
+        return 'Boolean';
+    }
+    if (firstType === Date) {
+        return 'Date';
+    }
+    if (firstType === Object) {
+        return 'Object';
+    }
+    if (firstType === Array) {
+        return 'Array';
+    }
+    var typeName = firstType.name || String(firstType);
+    if (typeName === 'Integer') {
+        return 'Number';
+    }
+    return typeName;
+}
+function toLabel(path) {
+    var last = path.split('.').pop() || path;
+    return last
+        .replace(/\$/g, '')
+        .replace(/_/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function isProtectedFieldSegment(segment) {
+    if (!segment) {
+        return false;
+    }
+    if (segment === '_id') {
+        return true;
+    }
+    var normalizedSegment = segment.replace(/\[\d+\]/g, '');
+    return normalizedSegment.toLowerCase().startsWith('id_');
+}
+function isProtectedFieldPath(path) {
+    var segments = String(path || '').split('.').filter(Boolean);
+    return segments.some(function (segment) { return isProtectedFieldSegment(segment); });
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch (_a) {
+        return String(value);
+    }
+}
+function collectProtectedFieldPaths(value, prefix, out) {
+    if (prefix === void 0) { prefix = ''; }
+    if (out === void 0) { out = {}; }
+    if (Array.isArray(value)) {
+        value.forEach(function (item, index) {
+            var nextPrefix = prefix ? "".concat(prefix, "[").concat(index, "]") : "[".concat(index, "]");
+            collectProtectedFieldPaths(item, nextPrefix, out);
+        });
+        return out;
+    }
+    if (!value || typeof value !== 'object') {
+        return out;
+    }
+    Object.keys(value).forEach(function (key) {
+        var nextPrefix = prefix ? "".concat(prefix, ".").concat(key) : key;
+        if (isProtectedFieldSegment(key)) {
+            out[nextPrefix] = value[key];
+        }
+        collectProtectedFieldPaths(value[key], nextPrefix, out);
+    });
+    return out;
+}
+function ensureProtectedFieldsUnchanged(originalDoc, updatedDoc) {
+    var originalProtected = collectProtectedFieldPaths(originalDoc || {});
+    var updatedProtected = collectProtectedFieldPaths(updatedDoc || {});
+    var violations = [];
+    Object.keys(originalProtected).forEach(function (path) {
+        if (!Object.prototype.hasOwnProperty.call(updatedProtected, path)) {
+            violations.push(path);
+            return;
+        }
+        var originalValue = safeStringify(originalProtected[path]);
+        var updatedValue = safeStringify(updatedProtected[path]);
+        if (originalValue !== updatedValue) {
+            violations.push(path);
+        }
+    });
+    Object.keys(updatedProtected).forEach(function (path) {
+        if (!Object.prototype.hasOwnProperty.call(originalProtected, path)) {
+            violations.push(path);
+        }
+    });
+    if (violations.length) {
+        var preview = violations.slice(0, 4).join(', ');
+        throw new Error("Mongo Explorer: Protected fields cannot be edited (".concat(preview).concat(violations.length > 4 ? ', ...' : '', ")"));
+    }
+}
+function coerceDateValue(value) {
+    if (value instanceof Date) {
+        return value;
+    }
+    if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
+        return value;
+    }
+    var parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? value : parsed;
+}
+function coerceDatePath(target, segments) {
+    if (!target || !segments.length) {
+        return;
+    }
+    var _a = __read(segments), segment = _a[0], rest = _a.slice(1);
+    if (segment === '$') {
+        if (Array.isArray(target)) {
+            target.forEach(function (item) { return coerceDatePath(item, rest); });
+        }
+        return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(target, segment)) {
+        return;
+    }
+    if (rest.length === 0) {
+        var updatedValue = coerceDateValue(target[segment]);
+        if (updatedValue !== target[segment]) {
+            target[segment] = updatedValue;
+        }
+        return;
+    }
+    coerceDatePath(target[segment], rest);
+}
+function coerceDateFields(collectionRef, doc) {
+    if (!collectionRef || !collectionRef.simplschema || !doc) {
+        return;
+    }
+    var schema = getSchemaDefinition(collectionRef);
+    Object.keys(schema).forEach(function (schemaKey) {
+        var _a;
+        var definition = schema[schemaKey];
+        var typeDefs = (_a = definition === null || definition === void 0 ? void 0 : definition.type) === null || _a === void 0 ? void 0 : _a.definitions;
+        if (!Array.isArray(typeDefs) || !typeDefs.some(function (typeDef) { return typeDef.type === Date; })) {
+            return;
+        }
+        coerceDatePath(doc, schemaKey.split('.'));
+    });
+}
 function normalizeFindOptions(options) {
     var normalized = options || {};
     var projection = normalized.projection && Object.keys(normalized.projection).length ? normalized.projection : undefined;
@@ -130,9 +362,9 @@ function userHasView(user, view) {
     }
     return false;
 }
-function ensureWriteAccess(context, permissionView) {
+function ensureWriteAccess(context, permissionView, mode) {
     return __awaiter(this, void 0, void 0, function () {
-        var idUser, user, allowedUsers, username_1, email_1, id_1, isAllowed, normalizedPermission;
+        var idUser, user, normalizedMode, allowedUsers, username_1, email_1, id_1, isAllowed, normalizedPermission;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
@@ -150,6 +382,10 @@ function ensureWriteAccess(context, permissionView) {
                     if (user.readonly) {
                         throw new Error('Mongo Explorer: Readonly user');
                     }
+                    normalizedMode = normalizeExplorerMode(mode);
+                    if (normalizedMode === 'resolveio' && !isAdminUser(user)) {
+                        throw new Error('Mongo Explorer: ResolveIO mode is read only for non-admin users');
+                    }
                     allowedUsers = parseMongoExplorerWriteUsers();
                     if (allowedUsers.length) {
                         username_1 = String(user.username || '').trim().toLowerCase();
@@ -181,6 +417,437 @@ function ensureWriteAccess(context, permissionView) {
         });
     });
 }
+function buildDeleteSafetyCollections(collectionRef) {
+    var schema = getSchemaDefinition(collectionRef);
+    return Object.keys(schema).filter(function (path) { return isProtectedFieldPath(path) && path !== '_id'; });
+}
+function buildDeleteImpact(database, sourceCollection, docId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var mainDb, mongoManager, collections, impacts, unresolved, collections_1, collections_1_1, collectionRef, collectionName, referencePaths, query, docs, _a, e_1_1;
+        var e_1, _b;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    mainDb = ((_c = resolveio_server_app_1.ResolveIOServer.getServerConfig()) === null || _c === void 0 ? void 0 : _c.DATABASE) || '';
+                    if (database !== mainDb) {
+                        return [2 /*return*/, {
+                                has_references: false,
+                                unresolved: true,
+                                collections: []
+                            }];
+                    }
+                    mongoManager = resolveio_server_app_1.ResolveIOServer.getMongoManager();
+                    collections = (mongoManager === null || mongoManager === void 0 ? void 0 : mongoManager.collections) ? mongoManager.collections() : [];
+                    impacts = [];
+                    unresolved = false;
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 8, 9, 10]);
+                    collections_1 = __values(collections), collections_1_1 = collections_1.next();
+                    _d.label = 2;
+                case 2:
+                    if (!!collections_1_1.done) return [3 /*break*/, 7];
+                    collectionRef = collections_1_1.value;
+                    collectionName = collectionRef === null || collectionRef === void 0 ? void 0 : collectionRef.collectionName;
+                    if (!collectionName) {
+                        return [3 /*break*/, 6];
+                    }
+                    if (collectionName === "".concat(sourceCollection, ".versions")) {
+                        return [3 /*break*/, 6];
+                    }
+                    referencePaths = buildDeleteSafetyCollections(collectionRef);
+                    if (!referencePaths.length) {
+                        return [3 /*break*/, 6];
+                    }
+                    query = {
+                        $or: referencePaths.map(function (path) {
+                            var _a;
+                            return (_a = {}, _a[path] = docId, _a);
+                        })
+                    };
+                    _d.label = 3;
+                case 3:
+                    _d.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, collectionRef.find(query, { projection: { _id: 1 }, limit: 3 })];
+                case 4:
+                    docs = _d.sent();
+                    if (Array.isArray(docs) && docs.length) {
+                        impacts.push({
+                            collection: collectionName,
+                            references: docs.length,
+                            sample_ids: docs.map(function (doc) { return String((doc === null || doc === void 0 ? void 0 : doc._id) || ''); }).filter(Boolean)
+                        });
+                    }
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _d.sent();
+                    unresolved = true;
+                    return [3 /*break*/, 6];
+                case 6:
+                    collections_1_1 = collections_1.next();
+                    return [3 /*break*/, 2];
+                case 7: return [3 /*break*/, 10];
+                case 8:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 10];
+                case 9:
+                    try {
+                        if (collections_1_1 && !collections_1_1.done && (_b = collections_1.return)) _b.call(collections_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 10: return [2 /*return*/, {
+                        has_references: impacts.length > 0,
+                        unresolved: unresolved,
+                        collections: impacts.sort(function (a, b) { return a.collection.localeCompare(b.collection); })
+                    }];
+            }
+        });
+    });
+}
+function normalizeOptionalString(value) {
+    if (typeof value === 'string') {
+        var trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    var normalized = String(value).trim();
+    return normalized.length ? normalized : undefined;
+}
+function normalizePositiveNumber(value, fallback) {
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+}
+function parseBooleanValue(value, fallback) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    var normalized = String(value || '').trim().toLowerCase();
+    if (!normalized.length) {
+        return fallback;
+    }
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function truncateForRiskReview(value, maxLength) {
+    if (maxLength === void 0) { maxLength = MAX_REVIEW_STRING_LENGTH; }
+    var normalized = String(value || '');
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    var diff = normalized.length - maxLength;
+    return "".concat(normalized.slice(0, maxLength), "...[+").concat(diff, " chars]");
+}
+function sanitizeForRiskReview(value, depth) {
+    if (depth === void 0) { depth = 0; }
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (depth > MAX_REVIEW_DEPTH) {
+        return '[Truncated depth]';
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'string') {
+        return truncateForRiskReview(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        var sanitized = value
+            .slice(0, MAX_REVIEW_ARRAY_ITEMS)
+            .map(function (item) { return sanitizeForRiskReview(item, depth + 1); });
+        if (value.length > MAX_REVIEW_ARRAY_ITEMS) {
+            sanitized.push("[".concat(value.length - MAX_REVIEW_ARRAY_ITEMS, " more item(s)]"));
+        }
+        return sanitized;
+    }
+    if (typeof value === 'object') {
+        var output_1 = {};
+        var keys = Object.keys(value);
+        var limitedKeys = keys.slice(0, MAX_REVIEW_OBJECT_KEYS);
+        limitedKeys.forEach(function (key) {
+            if (SENSITIVE_REVIEW_FIELD_REGEX.test(key)) {
+                output_1[key] = '[REDACTED]';
+                return;
+            }
+            output_1[key] = sanitizeForRiskReview(value[key], depth + 1);
+        });
+        if (keys.length > MAX_REVIEW_OBJECT_KEYS) {
+            output_1.__truncated_keys = keys.length - MAX_REVIEW_OBJECT_KEYS;
+        }
+        return output_1;
+    }
+    return truncateForRiskReview(String(value));
+}
+function pickChangedFields(beforeDocument, afterDocument) {
+    var e_2, _a;
+    if (!beforeDocument || typeof beforeDocument !== 'object' || !afterDocument || typeof afterDocument !== 'object') {
+        return [];
+    }
+    var changed = [];
+    var fieldNames = new Set(__spreadArray(__spreadArray([], __read(Object.keys(beforeDocument)), false), __read(Object.keys(afterDocument)), false));
+    try {
+        for (var fieldNames_1 = __values(fieldNames), fieldNames_1_1 = fieldNames_1.next(); !fieldNames_1_1.done; fieldNames_1_1 = fieldNames_1.next()) {
+            var field = fieldNames_1_1.value;
+            if (changed.length >= MAX_REVIEW_CHANGED_FIELDS) {
+                break;
+            }
+            var beforeValue = safeStringify(beforeDocument[field]);
+            var afterValue = safeStringify(afterDocument[field]);
+            if (beforeValue !== afterValue) {
+                changed.push(field);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (fieldNames_1_1 && !fieldNames_1_1.done && (_a = fieldNames_1.return)) _a.call(fieldNames_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return changed;
+}
+function normalizeRiskLevel(value) {
+    var normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'low') {
+        return 'low';
+    }
+    if (normalized === 'medium') {
+        return 'medium';
+    }
+    if (normalized === 'high') {
+        return 'high';
+    }
+    if (normalized === 'critical') {
+        return 'critical';
+    }
+    return 'high';
+}
+function normalizeRiskList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map(function (item) { return normalizeOptionalString(item); })
+        .filter(function (item) { return !!item; })
+        .slice(0, MAX_REVIEW_LIST_ITEMS)
+        .map(function (item) { return truncateForRiskReview(item, 220); });
+}
+function buildFallbackRiskReview(operation, summary, model) {
+    if (model === void 0) { model = ''; }
+    return {
+        operation: operation,
+        risk_level: 'high',
+        should_block: true,
+        summary: truncateForRiskReview(summary, 220),
+        reasons: [
+            'AI review could not produce a reliable result.',
+            'Proceed only with explicit approval and manual dependency checks.'
+        ],
+        suggested_checks: [
+            'Confirm related records and id_* references before writing.',
+            'Validate that schema-required fields and date values remain valid.'
+        ],
+        confidence: 0,
+        model: model || '',
+        request_id: '',
+        review_status: 'fallback',
+        reviewed_at: new Date().toISOString()
+    };
+}
+function buildDisabledRiskReview(operation) {
+    return {
+        operation: operation,
+        risk_level: 'low',
+        should_block: false,
+        summary: 'AI risk review is disabled by configuration.',
+        reasons: [],
+        suggested_checks: [],
+        confidence: 1,
+        model: '',
+        request_id: '',
+        review_status: 'disabled',
+        reviewed_at: new Date().toISOString()
+    };
+}
+function parseRiskReviewPayload(content) {
+    var normalized = String(content || '').trim();
+    if (!normalized.length) {
+        return {};
+    }
+    try {
+        return JSON.parse(normalized);
+    }
+    catch (_a) {
+        // Fall through and try to parse a JSON object embedded in plain text.
+    }
+    var start = normalized.indexOf('{');
+    var end = normalized.lastIndexOf('}');
+    if (start !== -1 && end > start) {
+        var candidate = normalized.slice(start, end + 1);
+        try {
+            return JSON.parse(candidate);
+        }
+        catch (_b) {
+            return {};
+        }
+    }
+    return {};
+}
+function normalizeRiskReview(operation, payload, model, requestId) {
+    var riskLevel = normalizeRiskLevel(payload === null || payload === void 0 ? void 0 : payload.risk_level);
+    var normalizedConfidence = Number(payload === null || payload === void 0 ? void 0 : payload.confidence);
+    var confidence = Number.isFinite(normalizedConfidence)
+        ? Math.max(0, Math.min(1, normalizedConfidence))
+        : 0.6;
+    var summary = normalizeOptionalString(payload === null || payload === void 0 ? void 0 : payload.summary)
+        || "Codex review marked this operation as ".concat(riskLevel, " risk.");
+    var reasons = normalizeRiskList(payload === null || payload === void 0 ? void 0 : payload.reasons);
+    var suggestedChecks = normalizeRiskList(payload === null || payload === void 0 ? void 0 : payload.suggested_checks);
+    var shouldBlock = (payload === null || payload === void 0 ? void 0 : payload.should_block) === true || riskLevel === 'critical';
+    return {
+        operation: operation,
+        risk_level: riskLevel,
+        should_block: !!shouldBlock,
+        summary: truncateForRiskReview(summary, 220),
+        reasons: reasons,
+        suggested_checks: suggestedChecks,
+        confidence: confidence,
+        model: model || '',
+        request_id: requestId || '',
+        review_status: 'ok',
+        reviewed_at: new Date().toISOString()
+    };
+}
+function resolveRiskReviewSettings() {
+    var _a, _b, _c, _d, _e;
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var enabled = parseBooleanValue((_a = serverConfig['MONGO_EXPLORER_ENABLE_AI_RISK_REVIEW']) !== null && _a !== void 0 ? _a : process.env.MONGO_EXPLORER_ENABLE_AI_RISK_REVIEW, true);
+    var model = normalizeOptionalString(serverConfig['MONGO_EXPLORER_RISK_REVIEW_MODEL']
+        || process.env.MONGO_EXPLORER_RISK_REVIEW_MODEL
+        || serverConfig['AI_ASSISTANT_CODEX_MODEL']
+        || process.env.AI_ASSISTANT_CODEX_MODEL
+        || serverConfig['AI_DASHBOARD_CODEX_MODEL']
+        || process.env.AI_DASHBOARD_CODEX_MODEL
+        || serverConfig['OPENAI_MODEL']
+        || process.env.OPENAI_MODEL) || DEFAULT_RISK_REVIEW_MODEL;
+    var fallbackModel = normalizeOptionalString(serverConfig['MONGO_EXPLORER_RISK_REVIEW_FALLBACK_MODEL']
+        || process.env.MONGO_EXPLORER_RISK_REVIEW_FALLBACK_MODEL
+        || serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODEL']
+        || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODEL
+        || serverConfig['AI_DASHBOARD_CODEX_FALLBACK_MODEL']
+        || process.env.AI_DASHBOARD_CODEX_FALLBACK_MODEL);
+    var timeoutMs = normalizePositiveNumber((_b = serverConfig['MONGO_EXPLORER_RISK_REVIEW_TIMEOUT_MS']) !== null && _b !== void 0 ? _b : process.env.MONGO_EXPLORER_RISK_REVIEW_TIMEOUT_MS, DEFAULT_RISK_REVIEW_TIMEOUT_MS);
+    var maxTokens = normalizePositiveNumber((_c = serverConfig['MONGO_EXPLORER_RISK_REVIEW_MAX_TOKENS']) !== null && _c !== void 0 ? _c : process.env.MONGO_EXPLORER_RISK_REVIEW_MAX_TOKENS, DEFAULT_RISK_REVIEW_MAX_TOKENS);
+    var maxRetries = normalizePositiveNumber((_d = serverConfig['OPENAI_MAX_RETRIES']) !== null && _d !== void 0 ? _d : process.env.OPENAI_MAX_RETRIES, 1);
+    var retryDelayMs = normalizePositiveNumber((_e = serverConfig['OPENAI_RETRY_DELAY_MS']) !== null && _e !== void 0 ? _e : process.env.OPENAI_RETRY_DELAY_MS, 750);
+    var apiKey = normalizeOptionalString(serverConfig['OPENAI_API_KEY'] || process.env.OPENAI_API_KEY) || '';
+    var baseUrl = normalizeOptionalString(serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL);
+    return {
+        enabled: enabled,
+        apiKey: apiKey,
+        baseUrl: baseUrl,
+        model: model,
+        fallbackModel: fallbackModel,
+        timeoutMs: timeoutMs,
+        maxTokens: maxTokens,
+        maxRetries: maxRetries,
+        retryDelayMs: retryDelayMs
+    };
+}
+function buildRiskReviewPrompt(input) {
+    var payload = {
+        database: input.database,
+        collection: input.collection,
+        operation: input.operation,
+        mode: input.mode,
+        changed_fields: pickChangedFields(input.before_document, input.after_document),
+        delete_impact: sanitizeForRiskReview(input.delete_impact || null),
+        before_document: sanitizeForRiskReview(input.before_document || null),
+        after_document: sanitizeForRiskReview(input.after_document || null)
+    };
+    return [
+        'Review this MongoDB write operation for runtime and data integrity risk.',
+        'Focus on foreign-key style id_* dependencies, schema compatibility, destructive impact, and financial/operational record safety.',
+        'Return JSON only.',
+        JSON.stringify(payload, null, 2)
+    ].join('\n');
+}
+function reviewOperationRisk(input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var settings, client, systemPrompt, response, payload, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    settings = resolveRiskReviewSettings();
+                    if (!settings.enabled) {
+                        return [2 /*return*/, buildDisabledRiskReview(input.operation)];
+                    }
+                    if (!settings.apiKey) {
+                        return [2 /*return*/, buildFallbackRiskReview(input.operation, 'AI risk review unavailable: OPENAI_API_KEY is missing.')];
+                    }
+                    client = new openai_client_1.OpenAIClient({
+                        apiKey: settings.apiKey,
+                        baseUrl: settings.baseUrl,
+                        model: settings.model,
+                        fallbackModel: settings.fallbackModel,
+                        temperature: 0.1,
+                        maxTokens: settings.maxTokens,
+                        maxRetries: (0, common_1.round)(settings.maxRetries),
+                        retryDelayMs: (0, common_1.round)(settings.retryDelayMs),
+                        responseFormat: 'json'
+                    });
+                    systemPrompt = [
+                        'You are a MongoDB operation safety reviewer for a production SaaS application.',
+                        'Respond with a single JSON object only.',
+                        'Required keys:',
+                        'risk_level ("low" | "medium" | "high" | "critical"),',
+                        'should_block (boolean),',
+                        'summary (string),',
+                        'reasons (string[]),',
+                        'suggested_checks (string[]),',
+                        'confidence (number between 0 and 1).',
+                        'Keep summary concise (<= 220 chars).'
+                    ].join(' ');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, client.chat([
+                            { role: 'system', content: systemPrompt },
+                            { role: 'user', content: buildRiskReviewPrompt(input) }
+                        ], {
+                            timeoutMs: (0, common_1.round)(settings.timeoutMs),
+                            responseFormat: 'json'
+                        })];
+                case 2:
+                    response = _a.sent();
+                    payload = parseRiskReviewPayload(response.content);
+                    return [2 /*return*/, normalizeRiskReview(input.operation, payload, response.model || settings.model, response.requestId || '')];
+                case 3:
+                    err_1 = _a.sent();
+                    detail = (err_1 === null || err_1 === void 0 ? void 0 : err_1.message) ? String(err_1.message) : 'Unknown AI review error';
+                    return [2 /*return*/, buildFallbackRiskReview(input.operation, "AI risk review failed: ".concat(truncateForRiskReview(detail, 160)), settings.model)];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
 function loadMongoExplorerMethods(methodManager) {
     methodManager.methods({
         mongoExplorerListCollections: {
@@ -259,6 +926,47 @@ function loadMongoExplorerMethods(methodManager) {
                 });
             }
         },
+        mongoExplorerGetCollectionSchema: {
+            check: new simpl_schema_1.default({
+                database: {
+                    type: String,
+                    optional: true
+                },
+                collection: {
+                    type: String
+                }
+            }),
+            function: function (database, collection) {
+                var dbName = resolveDatabaseName(database);
+                var managerCollection = resolveCollectionHandle(dbName, collection).managerCollection;
+                if (!managerCollection) {
+                    return Promise.resolve({
+                        collection: collection,
+                        has_schema: false,
+                        fields: []
+                    });
+                }
+                var schema = getSchemaDefinition(managerCollection);
+                var fields = Object.keys(schema)
+                    .sort(function (a, b) { return a.localeCompare(b); })
+                    .map(function (path) {
+                    var definition = schema[path];
+                    return {
+                        path: path,
+                        label: toLabel(path),
+                        type: getSchemaTypeName(definition),
+                        optional: (definition === null || definition === void 0 ? void 0 : definition.optional) === true,
+                        protected: isProtectedFieldPath(path),
+                        depth: path.split('.').filter(function (segment) { return segment !== '$'; }).length - 1
+                    };
+                });
+                return Promise.resolve({
+                    collection: collection,
+                    has_schema: true,
+                    fields: fields
+                });
+            }
+        },
         mongoExplorerAggregate: {
             bypassSession: true,
             check: new simpl_schema_1.default({
@@ -306,14 +1014,18 @@ function loadMongoExplorerMethods(methodManager) {
                 permissionView: {
                     type: String,
                     optional: true
+                },
+                mode: {
+                    type: String,
+                    optional: true
                 }
             }),
-            function: function (database, command, permissionView) {
+            function: function (database, command, permissionView, mode) {
                 return __awaiter(this, void 0, void 0, function () {
                     var db;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
-                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView)];
+                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView, mode)];
                             case 1:
                                 _a.sent();
                                 db = resolveDatabase(database);
@@ -339,14 +1051,18 @@ function loadMongoExplorerMethods(methodManager) {
                 permissionView: {
                     type: String,
                     optional: true
+                },
+                mode: {
+                    type: String,
+                    optional: true
                 }
             }),
-            function: function (database, collection, document, permissionView) {
+            function: function (database, collection, document, permissionView, mode) {
                 return __awaiter(this, void 0, void 0, function () {
                     var dbName, _a, managerCollection, dbCollection;
                     return __generator(this, function (_b) {
                         switch (_b.label) {
-                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView)];
+                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView, mode)];
                             case 1:
                                 _b.sent();
                                 dbName = resolveDatabaseName(database);
@@ -354,6 +1070,9 @@ function loadMongoExplorerMethods(methodManager) {
                                 if (!document || typeof document !== 'object') {
                                     throw new Error('Mongo Explorer: Document is required');
                                 }
+                                if (!managerCollection && !allowUnschemaizedWrites()) {
+                                    throw new Error('Mongo Explorer: Writes require schema-backed collections. Set MONGO_EXPLORER_ALLOW_UNSCHEMATIZED_WRITE=true to bypass.');
+                                }
                                 if (!document._id) {
                                     document._id = (0, common_1.objectIdHexString)();
                                 }
@@ -361,6 +1080,7 @@ function loadMongoExplorerMethods(methodManager) {
                                     document.__v = 0;
                                 }
                                 if (!managerCollection) return [3 /*break*/, 3];
+                                coerceDateFields(managerCollection, document);
                                 return [4 /*yield*/, managerCollection.insertOne(document)];
                             case 2:
                                 _b.sent();
@@ -391,31 +1111,114 @@ function loadMongoExplorerMethods(methodManager) {
                 permissionView: {
                     type: String,
                     optional: true
+                },
+                mode: {
+                    type: String,
+                    optional: true
                 }
             }),
-            function: function (database, collection, document, permissionView) {
+            function: function (database, collection, document, permissionView, mode) {
                 return __awaiter(this, void 0, void 0, function () {
-                    var dbName, _a, managerCollection, dbCollection;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView)];
+                    var dbName, _a, managerCollection, dbCollection, currentDoc, _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView, mode)];
                             case 1:
-                                _b.sent();
+                                _c.sent();
                                 dbName = resolveDatabaseName(database);
                                 _a = resolveCollectionHandle(dbName, collection), managerCollection = _a.managerCollection, dbCollection = _a.dbCollection;
                                 if (!document || typeof document !== 'object' || !document._id) {
                                     throw new Error('Mongo Explorer: Document with _id is required');
                                 }
                                 if (!managerCollection) return [3 /*break*/, 3];
-                                return [4 /*yield*/, managerCollection.replaceOne({ _id: document._id }, document)];
+                                return [4 /*yield*/, managerCollection.findOne({ _id: document._id })];
                             case 2:
-                                _b.sent();
+                                _b = _c.sent();
                                 return [3 /*break*/, 5];
-                            case 3: return [4 /*yield*/, dbCollection.replaceOne({ _id: document._id }, document)];
+                            case 3: return [4 /*yield*/, dbCollection.findOne({ _id: document._id })];
                             case 4:
-                                _b.sent();
-                                _b.label = 5;
-                            case 5: return [2 /*return*/, true];
+                                _b = _c.sent();
+                                _c.label = 5;
+                            case 5:
+                                currentDoc = _b;
+                                if (!currentDoc) {
+                                    throw new Error('Mongo Explorer: Document not found');
+                                }
+                                ensureProtectedFieldsUnchanged(currentDoc, document);
+                                if (!managerCollection && !allowUnschemaizedWrites()) {
+                                    throw new Error('Mongo Explorer: Writes require schema-backed collections. Set MONGO_EXPLORER_ALLOW_UNSCHEMATIZED_WRITE=true to bypass.');
+                                }
+                                if (!managerCollection) return [3 /*break*/, 7];
+                                coerceDateFields(managerCollection, document);
+                                return [4 /*yield*/, managerCollection.replaceOne({ _id: document._id }, document)];
+                            case 6:
+                                _c.sent();
+                                return [3 /*break*/, 9];
+                            case 7: return [4 /*yield*/, dbCollection.replaceOne({ _id: document._id }, document)];
+                            case 8:
+                                _c.sent();
+                                _c.label = 9;
+                            case 9: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
+        mongoExplorerReviewOperationRisk: {
+            check: new simpl_schema_1.default({
+                database: {
+                    type: String,
+                    optional: true
+                },
+                collection: {
+                    type: String
+                },
+                operation: {
+                    type: String,
+                    allowedValues: ['insert', 'replace', 'delete', 'command']
+                },
+                before_document: {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                after_document: {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                delete_impact: {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                permissionView: {
+                    type: String,
+                    optional: true
+                },
+                mode: {
+                    type: String,
+                    optional: true
+                }
+            }),
+            function: function (database, collection, operation, before_document, after_document, delete_impact, permissionView, mode) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var dbName;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView, mode)];
+                            case 1:
+                                _a.sent();
+                                dbName = resolveDatabaseName(database);
+                                return [2 /*return*/, reviewOperationRisk({
+                                        database: dbName,
+                                        collection: collection,
+                                        operation: operation,
+                                        mode: normalizeExplorerMode(mode),
+                                        before_document: before_document,
+                                        after_document: after_document,
+                                        delete_impact: delete_impact
+                                    })];
                         }
                     });
                 });
@@ -436,33 +1239,75 @@ function loadMongoExplorerMethods(methodManager) {
                 permissionView: {
                     type: String,
                     optional: true
+                },
+                force: {
+                    type: Boolean,
+                    optional: true
+                },
+                mode: {
+                    type: String,
+                    optional: true
                 }
             }),
-            function: function (database, collection, doc_id, permissionView) {
-                return __awaiter(this, void 0, void 0, function () {
-                    var dbName, _a, managerCollection, dbCollection, deleteFilter;
+            function: function (database_1, collection_1, doc_id_1, permissionView_1) {
+                return __awaiter(this, arguments, void 0, function (database, collection, doc_id, permissionView, force, mode) {
+                    var dbName, impact, collectionPreview, _a, managerCollection, dbCollection, deleteFilter;
+                    if (force === void 0) { force = false; }
                     return __generator(this, function (_b) {
                         switch (_b.label) {
-                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView)];
+                            case 0: return [4 /*yield*/, ensureWriteAccess(this, permissionView, mode)];
                             case 1:
                                 _b.sent();
                                 dbName = resolveDatabaseName(database);
+                                return [4 /*yield*/, buildDeleteImpact(dbName, collection, doc_id)];
+                            case 2:
+                                impact = _b.sent();
+                                if (!force && (impact.unresolved || impact.has_references)) {
+                                    collectionPreview = impact.collections.slice(0, 3).map(function (item) { return item.collection; }).join(', ');
+                                    if (impact.unresolved) {
+                                        throw new Error('Mongo Explorer: Delete blocked because dependency checks could not complete. Use force delete after review.');
+                                    }
+                                    throw new Error("Mongo Explorer: Delete blocked. Document is referenced by ".concat(collectionPreview).concat(impact.collections.length > 3 ? ', ...' : ''));
+                                }
                                 _a = resolveCollectionHandle(dbName, collection), managerCollection = _a.managerCollection, dbCollection = _a.dbCollection;
                                 deleteFilter = { _id: doc_id };
-                                if (!managerCollection) return [3 /*break*/, 3];
+                                if (!managerCollection) return [3 /*break*/, 4];
                                 return [4 /*yield*/, managerCollection.deleteOne(deleteFilter)];
-                            case 2:
+                            case 3:
                                 _b.sent();
-                                return [3 /*break*/, 5];
-                            case 3: return [4 /*yield*/, dbCollection.deleteOne(deleteFilter)];
-                            case 4:
+                                return [3 /*break*/, 6];
+                            case 4: return [4 /*yield*/, dbCollection.deleteOne(deleteFilter)];
+                            case 5:
                                 _b.sent();
-                                _b.label = 5;
-                            case 5: return [2 /*return*/, true];
+                                _b.label = 6;
+                            case 6: return [2 /*return*/, true];
                         }
                     });
                 });
             }
+        },
+        mongoExplorerDeleteImpact: {
+            check: new simpl_schema_1.default({
+                database: {
+                    type: String,
+                    optional: true
+                },
+                collection: {
+                    type: String
+                },
+                doc_id: {
+                    type: String
+                }
+            }),
+            function: function (database, collection, doc_id) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var dbName;
+                    return __generator(this, function (_a) {
+                        dbName = resolveDatabaseName(database);
+                        return [2 /*return*/, buildDeleteImpact(dbName, collection, doc_id)];
+                    });
+                });
+            }
         }
     });
 }