@resolveio/server-lib 20.14.4 → 20.14.6

package/methods/ai-terminal.js

@@ -48,6 +48,7 @@ var __values = (this && this.__values) || function(o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAiTerminalMethods = loadAiTerminalMethods;
+exports.executeAiAssistantMongoRead = executeAiAssistantMongoRead;
 var fs_1 = require("fs");
 var os = require("os");
 var path = require("path");
@@ -67,21 +68,79 @@ var DEFAULT_MAX_ATTACHMENT_CHARS = 12000;
 var DEFAULT_MAX_TOTAL_ATTACHMENT_CHARS = 40000;
 var DEFAULT_CODEX_MODEL = 'gpt-5.2-codex';
 var DEFAULT_CODEX_TIMEOUT_MS = 180000;
+var AI_ASSISTANT_MONGO_DEFAULT_LIMIT = 20;
+var AI_ASSISTANT_MONGO_MAX_LIMIT = 200;
+var AI_ASSISTANT_BLOCKED_COLLECTIONS = new Set([
+    'user-groups',
+    'logged-in-users',
+    'ai-terminal-messages',
+    'ai-terminal-conversations',
+    'openai-usage-ledger',
+    'logs',
+    'notifications',
+    'email-history'
+]);
+var AI_ASSISTANT_SENSITIVE_FIELDS = [
+    'password',
+    'salt',
+    'hash',
+    'secret',
+    'token',
+    'api_key',
+    'email',
+    'phonenumber',
+    'phone',
+    'ssn',
+    'address',
+    'services',
+    'roles'
+];
 var AI_ASSISTANT_SYSTEM_PROMPT = [
     'You are the ResolveIO in-app AI assistant running with read-only access to the codebase.',
-    '- Do not provide code snippets, full code, or file contents.',
-    '- Do not modify files, run destructive commands, or access databases.',
+    '- Never share code or file contents. All code is proprietary.',
+    '- Do not modify files, run destructive commands, or access databases directly.',
+    '- Read-only Mongo access is allowed only via the MONGO_READ directive (see below).',
     '- Do not access secrets, credentials, or user data.',
     '- Do not assist with hacking, bypassing security, or abuse.',
     '- Prefer high-level explanations and point to routes instead of code. Only mention file paths if explicitly requested.',
     '- When asked where to do something, give the exact screen name and the in-app route as a standalone path starting with "/" so it can be clicked.',
+    '- When asked "why is this happening," respond with: cause, trigger, data source(s), and expected vs actual outcome.',
+    '- For troubleshooting, ask 2-3 targeted questions first, then give a short decision tree (If X, do Y; If not, do Z).',
+    '- Provide checklists for common tasks, highlighting required fields and common pitfalls.',
+    '- If asked "where is this set," give the screen/workflow name and navigation steps to reach it.',
+    '- If asked "what changed," summarize release notes if known; if not available, say so and suggest where to check or offer a support ticket.',
+    '- Suggest 1-2 related screens or next steps when it helps.',
+    '- If access is blocked, name the permission/role needed and how to request it.',
     '- Avoid vague labels like "Operations app"; use the specific screen/workflow name.',
     '- Do not mention other client projects or ask which client; stay within the current project context.',
     '- Respond with a single concise message. Do not add labels like "Customer-facing summary" or "Work ticket summary" and do not include estimated hours.',
+    '- Use structured responses by default: short heading, then bullet points. For "how do I" questions, provide a step-by-step list (numbered) with explicit page/screen names and actions.',
+    '- When giving steps, include navigation guidance like "Go to <screen>" and "Click/Select/Enter <field>" so the user can follow it exactly.',
     '- If context scope is provided (ex: current page), prioritize that screen in your answer.',
     '- If a request is out of scope, offer to create a support ticket with a short summary.',
+    '- If the user explicitly asks to create/open/file a support ticket, end your response with a single line exactly in this format:',
+    '- SUPPORT_TICKET_CREATE: <one-line summary>',
+    '- Only include that line when the user clearly wants a ticket created. Do not claim a ticket is created unless you include that line.',
+    '- If you need database data to answer, end your response with a single line exactly in this format:',
+    '- MONGO_READ: {"collection":"<name>","query":{...},"options":{"projection":{...},"sort":{...},"limit":20},"permissionView":"</route>"}',
+    '- For invoice data, set permissionView to an invoice route (ex: /invoice/list or /report/invoice).',
+    '- Keep queries minimal, read-only, and avoid user/credential data unless the user is a super admin.',
+    '- Assume you are not a super admin unless explicitly told otherwise.',
+    '- Only request data when the user has permission for that module; invoice data requires invoice view access.',
+    '- If the user lacks permission, answer without data and explain how to view it in the app or request access.',
+    '- Use MONGO_READ only to produce summaries/snapshots/health checks (not raw dumps) when permitted.',
+    '- When referencing data, summarize it in bullets and avoid raw JSON or dumps.',
     '- Keep responses concise and use low reasoning effort.'
 ].join('\n');
+var AI_FORM_PATCH_SYSTEM_PROMPT = [
+    'You are the ResolveIO form patch assistant.',
+    '- Your job is to map the user request to the provided form fields.',
+    '- Only use the allowed fields and their types.',
+    '- Return ONLY valid JSON and nothing else.',
+    '- If you cannot map the request, return an empty patch with a short note.',
+    '- Use ISO 8601 for dates and true/false for booleans.',
+    '- Use medium reasoning effort.'
+].join('\n');
 var assistantCodexClient = null;
 function loadAiTerminalMethods(methodManager) {
     methodManager.methods({
@@ -267,6 +326,24 @@ function loadAiTerminalMethods(methodManager) {
                 });
             }
         },
+        aiFormPatch: {
+            check: new simpl_schema_1.default({
+                payload: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function (payload) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, executeAiFormPatch(payload, this)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                });
+            }
+        },
         aiCoderTerminalUploadFile: {
             check: new simpl_schema_1.default({
                 id_conversation: {
@@ -315,6 +392,24 @@ function loadAiTerminalMethods(methodManager) {
                 });
             }
         },
+        aiAssistantMongoRead: {
+            check: new simpl_schema_1.default({
+                payload: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function (payload) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, executeAiAssistantMongoRead(payload, this)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                });
+            }
+        },
         aiCoderTerminalDeployTest: {
             check: new simpl_schema_1.default({
                 id_conversation: {
@@ -483,11 +578,79 @@ function executeAiTerminalRun(payload, context) {
         });
     });
 }
-function executeAiAssistantCodexRun(payload, context) {
+function executeAiFormPatch(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, message, guardrail, conversation_2, now_2, userMsg, assistantMsg, conversation, now, attachments, attachmentData, historyLimit, history, _a, historyLines, prompt, workspaceRoot, codexClient, runOptions, responseText, assistantContent, userDoc, assistantDoc, insertResult;
+        var input, message, allowedFields, guardrail, systemPrompt, userPrompt, messages, openaiSettings, client, response, usage, idClient, parsed;
+        var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
+                case 0:
+                    input = payload || {};
+                    message = normalizeOptionalString(input.message);
+                    if (!message) {
+                        throw new Error('Message is required.');
+                    }
+                    if (!(context === null || context === void 0 ? void 0 : context.id_user)) {
+                        throw new Error('Unauthorized.');
+                    }
+                    allowedFields = normalizeAiFormFields(input.allowed_fields || input.fields);
+                    if (!allowedFields.length) {
+                        throw new Error('Allowed fields are required.');
+                    }
+                    guardrail = evaluateGuardrails(message);
+                    if (guardrail === null || guardrail === void 0 ? void 0 : guardrail.blocked) {
+                        return [2 /*return*/, { error: guardrail.response, blocked: true }];
+                    }
+                    systemPrompt = buildAiFormSystemPrompt();
+                    userPrompt = buildAiFormUserPrompt(message, allowedFields, input.patch_format, input.route);
+                    messages = [
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ];
+                    openaiSettings = resolveOpenAISettings(input.config || {});
+                    client = new openai_client_1.OpenAIClient(openaiSettings);
+                    return [4 /*yield*/, client.chat(messages, { timeoutMs: 60000, responseFormat: 'json_object' })];
+                case 1:
+                    response = _b.sent();
+                    usage = response.usage || estimateUsage(messages, response.content, response.model || openaiSettings.model);
+                    idClient = normalizeOptionalString(input.id_client);
+                    if (!idClient) return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
+                            id_client: idClient,
+                            model: response.model || openaiSettings.model || 'unknown',
+                            input_tokens: usage.inputTokens,
+                            output_tokens: usage.outputTokens,
+                            total_tokens: usage.totalTokens,
+                            category: 'ai-form'
+                        })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    parsed = parseJsonObject(response.content);
+                    if (!parsed || typeof parsed !== 'object') {
+                        throw new Error('AI form patch response was not valid JSON.');
+                    }
+                    return [2 /*return*/, {
+                            patch: (_a = parsed.patch) !== null && _a !== void 0 ? _a : parsed,
+                            notes: normalizeOptionalString(parsed.notes) || undefined,
+                            usage: {
+                                model: response.model || openaiSettings.model,
+                                input_tokens: usage.inputTokens,
+                                output_tokens: usage.outputTokens,
+                                total_tokens: usage.totalTokens
+                            }
+                        }];
+            }
+        });
+    });
+}
+function executeAiAssistantCodexRun(payload, context) {
+    return __awaiter(this, void 0, void 0, function () {
+        var input, message, guardrail, conversation_2, now_2, userMsg, assistantMsg, user, isSuperAdmin, hasInvoiceAccess, conversation, now, attachments, attachmentData, historyLimit, history, _a, historyLines, prompt, workspaceRoot, codexClient, runOptions, responseText, assistantContent, userDoc, assistantDoc, insertResult;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     input = payload || {};
                     message = normalizeOptionalString(input.message);
@@ -501,7 +664,7 @@ function executeAiAssistantCodexRun(payload, context) {
                     if (!(guardrail === null || guardrail === void 0 ? void 0 : guardrail.blocked)) return [3 /*break*/, 5];
                     return [4 /*yield*/, ensureConversation(input, 'codex')];
                 case 1:
-                    conversation_2 = _b.sent();
+                    conversation_2 = _c.sent();
                     now_2 = new Date();
                     userMsg = {
                         id_conversation: conversation_2._id,
@@ -523,36 +686,41 @@ function executeAiAssistantCodexRun(payload, context) {
                     };
                     return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.insertOne(userMsg)];
                 case 2:
-                    _b.sent();
+                    _c.sent();
                     return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.insertOne(assistantMsg)];
                 case 3:
-                    _b.sent();
+                    _c.sent();
                     return [4 /*yield*/, touchConversation(conversation_2._id, now_2)];
                 case 4:
-                    _b.sent();
+                    _c.sent();
                     return [2 /*return*/, {
                             conversation: conversation_2,
                             message: assistantMsg,
                             guardrails: { blocked: true, reason: guardrail.reason }
                         }];
-                case 5: return [4 /*yield*/, ensureConversation(input, 'codex')];
+                case 5: return [4 /*yield*/, user_collection_1.Users.findById(context === null || context === void 0 ? void 0 : context.id_user)];
                 case 6:
-                    conversation = _b.sent();
+                    user = _c.sent();
+                    isSuperAdmin = !!((_b = user === null || user === void 0 ? void 0 : user.roles) === null || _b === void 0 ? void 0 : _b.super_admin);
+                    hasInvoiceAccess = userHasInvoiceAccess(user);
+                    return [4 /*yield*/, ensureConversation(input, 'codex')];
+                case 7:
+                    conversation = _c.sent();
                     now = new Date();
                     attachments = Array.isArray(input.attachments) ? input.attachments : [];
                     return [4 /*yield*/, readAttachmentContents(attachments)];
-                case 7:
-                    attachmentData = _b.sent();
+                case 8:
+                    attachmentData = _c.sent();
                     historyLimit = normalizeHistoryLimit(input.max_history);
-                    if (!(historyLimit > 0)) return [3 /*break*/, 9];
+                    if (!(historyLimit > 0)) return [3 /*break*/, 10];
                     return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.find({ id_conversation: conversation._id, role: { $in: ['user', 'assistant'] } }, { sort: { createdAt: 1 }, limit: historyLimit * 2 })];
-                case 8:
-                    _a = _b.sent();
-                    return [3 /*break*/, 10];
                 case 9:
-                    _a = [];
-                    _b.label = 10;
+                    _a = _c.sent();
+                    return [3 /*break*/, 11];
                 case 10:
+                    _a = [];
+                    _c.label = 11;
+                case 11:
                     history = _a;
                     historyLines = [];
                     history.forEach(function (entry) {
@@ -562,10 +730,10 @@ function executeAiAssistantCodexRun(payload, context) {
                             historyLines.push("".concat(role, ": ").concat(content));
                         }
                     });
-                    prompt = buildAssistantCodexPrompt(message, attachmentData.promptText, historyLines.join('\n'), buildAssistantContext(input));
+                    prompt = buildAssistantCodexPrompt(message, attachmentData.promptText, historyLines.join('\n'), buildAssistantContext(input, { isSuperAdmin: isSuperAdmin, hasInvoiceAccess: hasInvoiceAccess }));
                     return [4 /*yield*/, resolveAssistantWorkspaceRoot()];
-                case 11:
-                    workspaceRoot = _b.sent();
+                case 12:
+                    workspaceRoot = _c.sent();
                     codexClient = getAssistantCodexClient();
                     runOptions = {
                         timeoutMs: resolveCodexTimeoutMs(),
@@ -581,8 +749,8 @@ function executeAiAssistantCodexRun(payload, context) {
                         }
                     };
                     return [4 /*yield*/, codexClient.run(prompt, runOptions)];
-                case 12:
-                    responseText = _b.sent();
+                case 13:
+                    responseText = _c.sent();
                     assistantContent = sanitizeAssistantResponse(responseText);
                     userDoc = {
                         id_conversation: conversation._id,
@@ -603,20 +771,20 @@ function executeAiAssistantCodexRun(payload, context) {
                         updatedAt: now
                     };
                     return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.insertOne(userDoc)];
-                case 13:
-                    _b.sent();
-                    return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.insertOne(assistantDoc)];
                 case 14:
-                    insertResult = _b.sent();
-                    return [4 /*yield*/, touchConversation(conversation._id, now, insertResult._id)];
+                    _c.sent();
+                    return [4 /*yield*/, ai_terminal_message_collection_1.AiTerminalMessages.insertOne(assistantDoc)];
                 case 15:
-                    _b.sent();
-                    if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 17];
-                    return [4 /*yield*/, cleanupAttachments(attachmentData.attachments)];
+                    insertResult = _c.sent();
+                    return [4 /*yield*/, touchConversation(conversation._id, now, insertResult._id)];
                 case 16:
-                    _b.sent();
-                    _b.label = 17;
-                case 17: return [2 /*return*/, {
+                    _c.sent();
+                    if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 18];
+                    return [4 /*yield*/, cleanupAttachments(attachmentData.attachments)];
+                case 17:
+                    _c.sent();
+                    _c.label = 18;
+                case 18: return [2 /*return*/, {
                         conversation: conversation,
                         message: assistantDoc
                     }];
@@ -624,6 +792,243 @@ function executeAiAssistantCodexRun(payload, context) {
         });
     });
 }
+function executeAiAssistantMongoRead(payload, context) {
+    return __awaiter(this, void 0, void 0, function () {
+        var input, collection, _a, user, isSuperAdmin, dbName, db, baseQuery, userId, scopedQuery, normalized, documents, total, sanitizedDocuments;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    input = payload || {};
+                    collection = normalizeOptionalString(input.collection);
+                    if (!collection) {
+                        throw new Error('AI assistant mongo read: Collection is required.');
+                    }
+                    return [4 /*yield*/, ensureAssistantReadAccess(context, input.permissionView, collection)];
+                case 1:
+                    _a = _b.sent(), user = _a.user, isSuperAdmin = _a.isSuperAdmin;
+                    if (!isSuperAdmin && AI_ASSISTANT_BLOCKED_COLLECTIONS.has(collection)) {
+                        throw new Error('AI assistant mongo read: Access denied.');
+                    }
+                    dbName = resolveAssistantDatabaseName(input.database, input.mongo);
+                    db = resolveio_server_app_1.ResolveIOServer.getMongoConnection().db(dbName);
+                    baseQuery = normalizeMongoQuery(input.query);
+                    if (!isSuperAdmin && (collection === 'users' || collection === 'user-versions')) {
+                        userId = normalizeOptionalString(user === null || user === void 0 ? void 0 : user._id);
+                        if (!userId) {
+                            throw new Error('AI assistant mongo read: Access denied.');
+                        }
+                        baseQuery = {
+                            $and: [baseQuery, { _id: userId }]
+                        };
+                    }
+                    scopedQuery = applyClientScopeFilter(baseQuery, input.id_client, isSuperAdmin);
+                    normalized = normalizeAssistantFindOptions(input.options);
+                    return [4 /*yield*/, db.collection(collection).find(scopedQuery, normalized.findOptions).toArray()];
+                case 2:
+                    documents = _b.sent();
+                    total = null;
+                    if (!normalized.includeTotal) return [3 /*break*/, 4];
+                    return [4 /*yield*/, db.collection(collection).countDocuments(scopedQuery)];
+                case 3:
+                    total = _b.sent();
+                    _b.label = 4;
+                case 4:
+                    sanitizedDocuments = isSuperAdmin
+                        ? documents
+                        : documents.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
+                    return [2 /*return*/, {
+                            documents: sanitizedDocuments,
+                            total: total
+                        }];
+            }
+        });
+    });
+}
+function ensureAssistantReadAccess(context, permissionView, collection) {
+    return __awaiter(this, void 0, void 0, function () {
+        var idUser, user, isSuperAdmin, normalizedPermission, normalizedCollection;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    idUser = context === null || context === void 0 ? void 0 : context.id_user;
+                    if (!idUser) {
+                        throw new Error('AI assistant mongo read: Unauthorized.');
+                    }
+                    return [4 /*yield*/, user_collection_1.Users.findById(idUser)];
+                case 1:
+                    user = _b.sent();
+                    if (!user) {
+                        throw new Error('AI assistant mongo read: Unauthorized.');
+                    }
+                    isSuperAdmin = !!((_a = user === null || user === void 0 ? void 0 : user.roles) === null || _a === void 0 ? void 0 : _a.super_admin);
+                    normalizedPermission = normalizeOptionalString(permissionView);
+                    if (!isSuperAdmin) {
+                        if (!normalizedPermission) {
+                            throw new Error('AI assistant mongo read: Permission scope required.');
+                        }
+                        if (!userHasViewPermission(user, normalizedPermission)) {
+                            throw new Error('AI assistant mongo read: Access denied.');
+                        }
+                        normalizedCollection = normalizeOptionalString(collection);
+                        if (normalizedCollection && requiresInvoicePermission(normalizedCollection) && !userHasInvoiceAccess(user)) {
+                            throw new Error('AI assistant mongo read: Access denied.');
+                        }
+                    }
+                    else if (normalizedPermission && !userHasViewPermission(user, normalizedPermission)) {
+                        throw new Error('AI assistant mongo read: Access denied.');
+                    }
+                    return [2 /*return*/, { user: user, isSuperAdmin: isSuperAdmin }];
+            }
+        });
+    });
+}
+function resolveAssistantDatabaseName(database, mongoConfig) {
+    var _a, _b;
+    var defaultDb = normalizeOptionalString(mongoConfig === null || mongoConfig === void 0 ? void 0 : mongoConfig.database) || ((_a = resolveio_server_app_1.ResolveIOServer.getServerConfig()) === null || _a === void 0 ? void 0 : _a.DATABASE) || '';
+    var dbName = normalizeOptionalString(database) || defaultDb;
+    if (!dbName) {
+        throw new Error('AI assistant mongo read: Database is required.');
+    }
+    var allowedFromConfig = Array.isArray(mongoConfig === null || mongoConfig === void 0 ? void 0 : mongoConfig.databases)
+        ? mongoConfig === null || mongoConfig === void 0 ? void 0 : mongoConfig.databases.map(function (value) { return normalizeOptionalString(value); }).filter(Boolean)
+        : [];
+    if (allowedFromConfig.length && !allowedFromConfig.includes(dbName)) {
+        throw new Error('AI assistant mongo read: Database access denied.');
+    }
+    var allowedDatabases = ((_b = resolveio_server_app_1.ResolveIOServer.getMongoManager()) === null || _b === void 0 ? void 0 : _b.getWatchedDatabases()) || [];
+    if (allowedDatabases.length && !allowedDatabases.includes(dbName)) {
+        throw new Error('AI assistant mongo read: Database access denied.');
+    }
+    return dbName;
+}
+function normalizeAssistantFindOptions(options) {
+    var normalized = options || {};
+    var projection = normalized.projection && Object.keys(normalized.projection).length ? normalized.projection : undefined;
+    var sort = normalized.sort && Object.keys(normalized.sort).length ? normalized.sort : undefined;
+    var limit = typeof normalized.limit === 'number'
+        ? Math.min(Math.max(normalized.limit, 0), AI_ASSISTANT_MONGO_MAX_LIMIT)
+        : AI_ASSISTANT_MONGO_DEFAULT_LIMIT;
+    var skip = typeof normalized.skip === 'number' ? Math.max(normalized.skip, 0) : 0;
+    return {
+        findOptions: {
+            projection: projection,
+            sort: sort,
+            limit: limit,
+            skip: skip
+        },
+        includeTotal: normalized.includeTotal === true
+    };
+}
+function normalizeMongoQuery(query) {
+    var normalized = query && typeof query === 'object' ? query : {};
+    if (containsForbiddenMongoOperators(normalized)) {
+        throw new Error('AI assistant mongo read: Query contains restricted operators.');
+    }
+    return normalized;
+}
+function containsForbiddenMongoOperators(value) {
+    var e_1, _a;
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.some(function (entry) { return containsForbiddenMongoOperators(entry); });
+    }
+    try {
+        for (var _b = __values(Object.keys(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var normalized = key.toLowerCase();
+            if (normalized === '$where' || normalized === '$function' || normalized === '$accumulator') {
+                return true;
+            }
+            if (containsForbiddenMongoOperators(value[key])) {
+                return true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return false;
+}
+function applyClientScopeFilter(query, idClient, isSuperAdmin) {
+    if (isSuperAdmin === void 0) { isSuperAdmin = false; }
+    if (isSuperAdmin) {
+        return query;
+    }
+    var normalizedClient = normalizeOptionalString(idClient);
+    if (!normalizedClient) {
+        return query;
+    }
+    return {
+        $and: [query, { id_client: normalizedClient }]
+    };
+}
+function userHasViewPermission(user, view) {
+    var _a, _b, _c;
+    if (!user || !view) {
+        return false;
+    }
+    if ((_a = user.roles) === null || _a === void 0 ? void 0 : _a.super_admin) {
+        return true;
+    }
+    var groups = Array.isArray((_b = user.roles) === null || _b === void 0 ? void 0 : _b.groups) ? user.roles.groups : [];
+    var miscs = Array.isArray((_c = user.roles) === null || _c === void 0 ? void 0 : _c.miscs) ? user.roles.miscs : [];
+    if (groups.some(function (group) { return Array.isArray(group.views) && group.views.some(function (v) { return v.startsWith(view); }); })) {
+        return true;
+    }
+    if (miscs.some(function (v) { return v.startsWith(view); })) {
+        return true;
+    }
+    if (groups.some(function (group) { return group.name === view; })) {
+        return true;
+    }
+    return false;
+}
+function userHasAnyViewPermission(user, views) {
+    if (!user || !Array.isArray(views)) {
+        return false;
+    }
+    return views.some(function (view) { return view && userHasViewPermission(user, view); });
+}
+function userHasInvoiceAccess(user) {
+    return userHasAnyViewPermission(user, ['/invoice', '/report/invoice']);
+}
+function requiresInvoicePermission(collection) {
+    var normalized = normalizeOptionalString(collection).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return normalized.includes('invoice');
+}
+function redactSensitiveFields(value) {
+    if (Array.isArray(value)) {
+        return value.map(function (entry) { return redactSensitiveFields(entry); });
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    var result = {};
+    Object.keys(value).forEach(function (key) {
+        if (shouldRedactField(key)) {
+            return;
+        }
+        result[key] = redactSensitiveFields(value[key]);
+    });
+    return result;
+}
+function shouldRedactField(key) {
+    var normalized = String(key || '').trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return AI_ASSISTANT_SENSITIVE_FIELDS.some(function (field) { return normalized === field || normalized.includes(field); });
+}
 function resolveCodexTimeoutMs() {
     var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
     var raw = normalizeOptionalNumber(config['AI_ASSISTANT_CODEX_TIMEOUT_MS'] || process.env.AI_ASSISTANT_CODEX_TIMEOUT_MS);
@@ -702,13 +1107,19 @@ function buildAssistantCodexPrompt(message, attachmentText, historyText, context
     var historyBlock = trimmedHistory ? "\n\nConversation so far:\n".concat(trimmedHistory) : '';
     return "System:\n".concat(AI_ASSISTANT_SYSTEM_PROMPT).concat(contextBlock).concat(historyBlock, "\n\nUser:\n").concat(message).concat(attachmentText || '').trim();
 }
-function buildAssistantContext(input) {
-    var _a, _b;
+function buildAssistantContext(input, userContext) {
+    var _a, _b, _c, _d, _e, _f;
     var lines = [];
     var idApp = normalizeOptionalString(input === null || input === void 0 ? void 0 : input.id_app);
     if (idApp) {
         lines.push("Current app id: ".concat(idApp));
     }
+    if (typeof (userContext === null || userContext === void 0 ? void 0 : userContext.isSuperAdmin) === 'boolean') {
+        lines.push("User is super admin: ".concat(userContext.isSuperAdmin ? 'yes' : 'no'));
+    }
+    if (typeof (userContext === null || userContext === void 0 ? void 0 : userContext.hasInvoiceAccess) === 'boolean') {
+        lines.push("User has invoice access: ".concat(userContext.hasInvoiceAccess ? 'yes' : 'no'));
+    }
     var contextMode = normalizeOptionalString((_a = input === null || input === void 0 ? void 0 : input.context) === null || _a === void 0 ? void 0 : _a.mode);
     var contextRoute = normalizeOptionalString((_b = input === null || input === void 0 ? void 0 : input.context) === null || _b === void 0 ? void 0 : _b.route);
     if (contextMode) {
@@ -717,8 +1128,136 @@ function buildAssistantContext(input) {
     if (contextRoute) {
         lines.push("Current page route: ".concat(contextRoute));
     }
+    var mongoDb = normalizeOptionalString((_c = input === null || input === void 0 ? void 0 : input.mongo) === null || _c === void 0 ? void 0 : _c.database);
+    var mongoDbs = Array.isArray((_d = input === null || input === void 0 ? void 0 : input.mongo) === null || _d === void 0 ? void 0 : _d.databases)
+        ? input.mongo.databases.map(function (value) { return normalizeOptionalString(value); }).filter(Boolean)
+        : [];
+    var mongoAccess = normalizeOptionalString((_e = input === null || input === void 0 ? void 0 : input.mongo) === null || _e === void 0 ? void 0 : _e.access)
+        || (((_f = input === null || input === void 0 ? void 0 : input.mongo) === null || _f === void 0 ? void 0 : _f.readonly) === true ? 'read' : '');
+    if (mongoDb) {
+        lines.push("Mongo database: ".concat(mongoDb));
+    }
+    if (mongoDbs.length) {
+        lines.push("Mongo databases allowed: ".concat(mongoDbs.join(', ')));
+    }
+    if (mongoAccess) {
+        lines.push("Mongo access: ".concat(mongoAccess));
+    }
     return lines.join('\n');
 }
+var cachedClientRouteIndex = null;
+function normalizeRouteKey(value) {
+    var trimmed = normalizeOptionalString(value);
+    if (!trimmed) {
+        return '';
+    }
+    var withSlash = trimmed.startsWith('/') ? trimmed : "/".concat(trimmed);
+    return withSlash.replace(/\/+$/, '');
+}
+function normalizeRouteMatchKey(value) {
+    return normalizeRouteKey(value).toLowerCase();
+}
+function buildClientRouteIndex() {
+    var e_2, _a;
+    var _b;
+    var routes = ((_b = resolveio_server_app_1.ResolveIOServer.getClientRoutes) === null || _b === void 0 ? void 0 : _b.call(resolveio_server_app_1.ResolveIOServer)) || [];
+    var set = new Set();
+    var map = new Map();
+    try {
+        for (var routes_1 = __values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) {
+            var route = routes_1_1.value;
+            var normalized = normalizeRouteKey(route);
+            if (!normalized) {
+                continue;
+            }
+            var matchKey = normalized.toLowerCase();
+            set.add(matchKey);
+            if (!map.has(matchKey)) {
+                map.set(matchKey, normalized);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return { set: set, map: map, size: routes.length };
+}
+function getClientRouteIndex() {
+    var _a;
+    var routes = ((_a = resolveio_server_app_1.ResolveIOServer.getClientRoutes) === null || _a === void 0 ? void 0 : _a.call(resolveio_server_app_1.ResolveIOServer)) || [];
+    if (cachedClientRouteIndex && cachedClientRouteIndex.size === routes.length) {
+        return cachedClientRouteIndex;
+    }
+    cachedClientRouteIndex = buildClientRouteIndex();
+    return cachedClientRouteIndex;
+}
+function splitRouteSuffix(value) {
+    var matchIndex = value.search(/[?#]/);
+    if (matchIndex === -1) {
+        return { base: value, suffix: '' };
+    }
+    return { base: value.slice(0, matchIndex), suffix: value.slice(matchIndex) };
+}
+function isClientRoute(value, index) {
+    var normalized = normalizeRouteMatchKey(value);
+    if (!normalized) {
+        return false;
+    }
+    if (index.set.has(normalized)) {
+        return true;
+    }
+    var parts = normalized.split('/').filter(Boolean);
+    while (parts.length > 1) {
+        parts.pop();
+        var prefix = "/".concat(parts.join('/'));
+        if (index.set.has(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getCanonicalRoute(value, index) {
+    var normalized = normalizeRouteMatchKey(value);
+    if (!normalized) {
+        return null;
+    }
+    return index.map.get(normalized) || null;
+}
+function swapTwoSegmentRoute(value) {
+    var normalized = normalizeRouteKey(value);
+    if (!normalized) {
+        return null;
+    }
+    var parts = normalized.split('/').filter(Boolean);
+    if (parts.length !== 2) {
+        return null;
+    }
+    return "/".concat(parts[1], "/").concat(parts[0]);
+}
+function normalizeAssistantRoutes(value) {
+    var index = getClientRouteIndex();
+    if (!index.set.size) {
+        return value;
+    }
+    var routePattern = /\/[a-z0-9][a-z0-9/_-]*(?:\?[a-z0-9=&%._-]+)?(?:#[a-z0-9._-]+)?/gi;
+    return value.replace(routePattern, function (match) {
+        var _a = splitRouteSuffix(match), base = _a.base, suffix = _a.suffix;
+        if (isClientRoute(base, index)) {
+            var canonical_1 = getCanonicalRoute(base, index);
+            return canonical_1 ? "".concat(canonical_1).concat(suffix) : match;
+        }
+        var swapped = swapTwoSegmentRoute(base);
+        if (!swapped || !isClientRoute(swapped, index)) {
+            return match;
+        }
+        var canonical = getCanonicalRoute(swapped, index) || swapped;
+        return "".concat(canonical).concat(suffix);
+    });
+}
 function sanitizeAssistantResponse(value) {
     var raw = normalizeOptionalString(value);
     if (!raw) {
@@ -753,21 +1292,21 @@ function sanitizeAssistantResponse(value) {
     if (!cleaned) {
         return 'I can’t share code, but I can point you to files or explain behavior at a high level.';
     }
-    return cleaned;
+    return normalizeAssistantRoutes(cleaned);
 }
 function evaluateAssistantGuardrails(message) {
-    var e_1, _a;
+    var e_3, _a;
     var normalized = String(message || '').toLowerCase();
     var patterns = [
         {
             pattern: /\b(show|share|paste|provide|dump|output)\b.*\b(code|snippet|file|function|class|script|sql)\b/i,
             reason: 'Code sharing is restricted.',
-            response: 'I can’t share code. I can explain behavior and point you to file paths or routes.'
+            response: 'I can’t share code or file contents. All code is proprietary. I can explain behavior and point you to screens or routes.'
         },
         {
             pattern: /\b(write|generate|create|implement|fix)\b.*\b(code|script|function|class|endpoint|sql)\b/i,
             reason: 'Code generation is restricted.',
-            response: 'I can’t generate code. I can explain how the feature works and where to look in the project.'
+            response: 'I can’t generate code. All code is proprietary. I can explain how the feature works and where to look in the product.'
         },
         {
             pattern: /\b(credentials?|passwords?|secrets?|tokens?)\b/i,
@@ -802,12 +1341,12 @@ function evaluateAssistantGuardrails(message) {
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
             if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_3) throw e_3.error; }
     }
     return null;
 }
@@ -827,6 +1366,93 @@ function resolveOpenAISettings(config) {
         retryDelayMs: normalizeOptionalNumber(serverConfig['OPENAI_RETRY_DELAY_MS'] || process.env.OPENAI_RETRY_DELAY_MS)
     };
 }
+function buildAiFormSystemPrompt() {
+    return AI_FORM_PATCH_SYSTEM_PROMPT;
+}
+function buildAiFormUserPrompt(message, fields, patchFormat, route) {
+    var lines = [];
+    lines.push("User request: ".concat(message));
+    var normalizedRoute = normalizeOptionalString(route);
+    if (normalizedRoute) {
+        lines.push("Current route: ".concat(normalizedRoute));
+    }
+    if (patchFormat) {
+        lines.push('Patch format:');
+        lines.push(patchFormat);
+    }
+    lines.push('Allowed fields:');
+    fields.forEach(function (field) {
+        var name = field.name || '';
+        if (!name) {
+            return;
+        }
+        var parts = [name];
+        if (field.type) {
+            parts.push("type=".concat(field.type));
+        }
+        if (field.label) {
+            parts.push("label=\"".concat(field.label, "\""));
+        }
+        if (Array.isArray(field.enums) && field.enums.length) {
+            parts.push("enums=".concat(field.enums.join('|')));
+        }
+        lines.push("- ".concat(parts.join(' ')));
+    });
+    lines.push('Return JSON only.');
+    return lines.join('\n');
+}
+function normalizeAiFormFields(fields) {
+    if (!Array.isArray(fields)) {
+        return [];
+    }
+    return fields
+        .map(function (field) {
+        if (!field || typeof field !== 'object') {
+            return null;
+        }
+        var name = normalizeOptionalString(field.name) || normalizeOptionalString(field.path);
+        if (!name) {
+            return null;
+        }
+        var type = normalizeOptionalString(field.type);
+        var label = normalizeOptionalString(field.label);
+        var enums = Array.isArray(field.enums)
+            ? field.enums.map(function (value) { return normalizeOptionalString(value); }).filter(Boolean)
+            : undefined;
+        var normalizedField = { name: name };
+        if (type) {
+            normalizedField.type = type;
+        }
+        if (label) {
+            normalizedField.label = label;
+        }
+        if (enums && enums.length) {
+            normalizedField.enums = enums;
+        }
+        return normalizedField;
+    })
+        .filter(function (field) { return !!field; });
+}
+function parseJsonObject(content) {
+    if (!content || typeof content !== 'string') {
+        return null;
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch (_a) {
+        var match = content.match(/\{[\s\S]*\}/);
+        if (!match) {
+            return null;
+        }
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch (_b) {
+            return null;
+        }
+    }
+}
 function resolveUploadLimits() {
     var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
     var maxFileMb = normalizeOptionalNumber(config['AI_TERMINAL_MAX_FILE_MB'] || process.env.AI_TERMINAL_MAX_FILE_MB) || DEFAULT_MAX_FILE_MB;
@@ -884,8 +1510,8 @@ function handleCodexUpload(id_conversation, file_name, content_base64, size, con
 }
 function readAttachmentContents(attachments) {
     return __awaiter(this, void 0, void 0, function () {
-        var limits, totalBytes, totalChars, chunks, cleaned, attachments_1, attachments_1_1, attachment, localPath, safe, stat, ext, name_1, type, readable, content, _a, e_2_1;
-        var e_2, _b;
+        var limits, totalBytes, totalChars, chunks, cleaned, attachments_1, attachments_1_1, attachment, localPath, safe, stat, ext, name_1, type, readable, content, _a, e_4_1;
+        var e_4, _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
@@ -964,14 +1590,14 @@ function readAttachmentContents(attachments) {
                     return [3 /*break*/, 2];
                 case 10: return [3 /*break*/, 13];
                 case 11:
-                    e_2_1 = _c.sent();
-                    e_2 = { error: e_2_1 };
+                    e_4_1 = _c.sent();
+                    e_4 = { error: e_4_1 };
                     return [3 /*break*/, 13];
                 case 12:
                     try {
                         if (attachments_1_1 && !attachments_1_1.done && (_b = attachments_1.return)) _b.call(attachments_1);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
                 case 13: return [2 /*return*/, {
                         promptText: chunks.length ? "\n\nAttachments:\n".concat(chunks.join('\n\n')) : '',
@@ -1124,10 +1750,11 @@ function estimateUsage(messages, responseText, model) {
     };
 }
 function evaluateGuardrails(message) {
-    var e_3, _a;
+    var e_5, _a;
     var normalized = String(message || '').toLowerCase();
     var patterns = [
         { pattern: /\b(source\s*code|full\s*code|entire\s*code|repo\s*dump|repository|git\s*clone)\b/i, reason: 'Code access is restricted.' },
+        { pattern: /\b(show|share|paste|provide|dump|output)\b.*\b(code|file|contents|snippet)\b/i, reason: 'Code access is restricted.' },
         { pattern: /\b(credentials?|passwords?|secrets?|tokens?)\b/i, reason: 'Credentials and secrets are restricted.' },
         { pattern: /\b(delete|drop)\s+(database|db|schema)\b/i, reason: 'Database operations are restricted.' },
         { pattern: /\b(shell|terminal|ssh|sudo|rm\s+-rf|chmod|chown)\b/i, reason: 'Server operations are restricted.' },
@@ -1140,17 +1767,17 @@ function evaluateGuardrails(message) {
                 return {
                     blocked: true,
                     reason: entry.reason,
-                    response: 'I can’t help with that request because it could impact system security or expose protected information. If you need a change, describe the outcome and I can help within approved workflows.'
+                    response: 'I can’t help with that request because it could expose proprietary code or protected information. If you need a change, describe the outcome and I can help within approved workflows.'
                 };
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
     finally {
         try {
             if (patterns_2_1 && !patterns_2_1.done && (_a = patterns_2.return)) _a.call(patterns_2);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_5) throw e_5.error; }
     }
     return null;
 }