n8n 2.19.2 → 2.20.0

package/dist/modules/instance-ai/instance-ai.adapter.service.js

@@ -46,8 +46,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceAiAdapterService = void 0;
+exports.resolveDataTableByIdOrName = resolveDataTableByIdOrName;
 exports.truncateResultData = truncateResultData;
 exports.extractExecutionResult = extractExecutionResult;
+exports.formatExecutionError = formatExecutionError;
 exports.truncateNodeOutput = truncateNodeOutput;
 exports.extractNodeOutput = extractNodeOutput;
 exports.extractExecutionDebugInfo = extractExecutionDebugInfo;
@@ -74,6 +76,7 @@ const event_service_1 = require("../../events/event.service");
 const execution_persistence_1 = require("../../executions/execution-persistence");
 const license_1 = require("../../license");
 const load_nodes_and_credentials_1 = require("../../load-nodes-and-credentials");
+const node_types_1 = require("../../node-types");
 const data_table_repository_1 = require("../../modules/data-table/data-table.repository");
 const data_table_service_1 = require("../../modules/data-table/data-table.service");
 const source_control_preferences_service_ee_1 = require("../../modules/source-control.ee/source-control-preferences.service.ee");
@@ -82,6 +85,7 @@ const dynamic_node_parameters_service_1 = require("../../services/dynamic-node-p
 const folder_service_1 = require("../../services/folder.service");
 const project_service_ee_1 = require("../../services/project.service.ee");
 const role_service_1 = require("../../services/role.service");
+const ssrf_protection_service_1 = require("../../services/ssrf/ssrf-protection.service");
 const tag_service_1 = require("../../services/tag.service");
 const workflow_finder_service_1 = require("../../workflows/workflow-finder.service");
 const workflow_history_service_1 = require("../../workflows/workflow-history/workflow-history.service");
@@ -103,7 +107,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         });
         return await promise;
     }
-    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, instanceSettings, dataTableService, dataTableRepository, dynamicNodeParametersService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository) {
+    constructor(logger, globalConfig, workflowService, workflowFinderService, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, credentialsService, credentialsFinderService, activeExecutions, workflowRunner, loadNodesAndCredentials, nodeTypes, instanceSettings, dataTableService, dataTableRepository, dynamicNodeParametersService, folderService, projectService, tagService, sourceControlPreferencesService, settingsService, workflowHistoryService, enterpriseWorkflowService, license, executionPersistence, eventService, roleService, telemetry, aiBuilderTemporaryWorkflowRepository, ssrfProtectionService) {
         this.workflowService = workflowService;
         this.workflowFinderService = workflowFinderService;
         this.workflowRepository = workflowRepository;
@@ -115,6 +119,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.activeExecutions = activeExecutions;
         this.workflowRunner = workflowRunner;
         this.loadNodesAndCredentials = loadNodesAndCredentials;
+        this.nodeTypes = nodeTypes;
         this.instanceSettings = instanceSettings;
         this.dataTableService = dataTableService;
         this.dataTableRepository = dataTableRepository;
@@ -132,6 +137,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         this.roleService = roleService;
         this.telemetry = telemetry;
         this.aiBuilderTemporaryWorkflowRepository = aiBuilderTemporaryWorkflowRepository;
+        this.ssrfProtectionService = ssrfProtectionService;
         this.nodesCache = null;
         this.NODES_CACHE_TTL_MS = 5 * 60 * 1000;
         this.webResearchCache = new web_research_1.LRUCache({
@@ -158,6 +164,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
             workspaceService: this.createWorkspaceAdapter(user),
             licenseHints: this.buildLicenseHints(),
             logger: this.logger,
+            nodeTypesProvider: this.nodeTypes,
         };
     }
     buildLicenseHints() {
@@ -516,7 +523,15 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     executionMode: triggerNode
                         ? getExecutionModeForTrigger(triggerNode)
                         : 'manual',
-                    workflowData: workflow,
+                    workflowData: {
+                        ...workflow,
+                        settings: {
+                            ...workflow.settings,
+                            saveManualExecutions: true,
+                            saveDataSuccessExecution: 'all',
+                            saveDataErrorExecution: 'all',
+                        },
+                    },
                     userId: user.id,
                     pushRef,
                 };
@@ -689,7 +704,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     id: credential.id,
                     name: credential.name,
                     type: credential.type,
-                    data: credentialsService.decrypt(credential, true),
+                    data: await credentialsService.decrypt(credential, true),
                 };
                 const result = await credentialsService.test(user.id, credentialsToTest);
                 return {
@@ -826,7 +841,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     return id.slice(0, 2) + '***' + id.slice(-1);
                 };
                 try {
-                    const redacted = credentialsService.decrypt(credential, false);
+                    const redacted = await credentialsService.decrypt(credential, false);
                     if (typeof redacted.accountIdentifier === 'string' && redacted.accountIdentifier) {
                         return { accountIdentifier: mask(redacted.accountIdentifier) };
                     }
@@ -836,7 +851,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                             return { accountIdentifier: mask(value) };
                         }
                     }
-                    const raw = credentialsService.decrypt(credential, true);
+                    const raw = await credentialsService.decrypt(credential, true);
                     const tokenData = raw.oauthTokenData;
                     if (tokenData && typeof tokenData === 'object') {
                         const { OauthService } = await Promise.resolve().then(() => __importStar(require('../../oauth/oauth.service')));
@@ -857,21 +872,33 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         const { dataTableService, dataTableRepository } = this;
         const assertNotReadOnly = () => this.assertInstanceNotReadOnly('data tables');
         const { resolveProjectId } = this.createProjectScopeHelpers(user);
-        const resolveProjectIdForTable = async (scopes, dataTableId) => {
-            const allowed = await (0, check_access_1.userHasScopes)(user, scopes, false, { dataTableId });
-            if (!allowed) {
+        const logger = this.logger;
+        const resolveAccessibleTable = async (scopes, dataTableId, disambiguator) => {
+            const projectIdFilter = disambiguator?.projectId;
+            const result = await resolveDataTableByIdOrName(dataTableRepository, logger, dataTableId, {
+                projectIdFilter,
+                accessFilter: async (id) => await (0, check_access_1.userHasScopes)(user, scopes, false, { dataTableId: id }),
+            });
+            if (result.kind === 'miss') {
                 throw new Error(`Data table "${dataTableId}" not found`);
             }
-            const table = await dataTableRepository.findOneByOrFail({ id: dataTableId });
-            return table.projectId;
-        };
-        const resolveTableMeta = async (scopes, dataTableId) => {
-            const allowed = await (0, check_access_1.userHasScopes)(user, scopes, false, { dataTableId });
-            if (!allowed) {
-                throw new Error(`Data table "${dataTableId}" not found`);
+            if (result.kind === 'ambiguous') {
+                const projectIds = result.candidates.map((c) => c.projectId).join(', ');
+                throw new Error(`Data table name "${dataTableId}" is ambiguous across accessible projects ` +
+                    `(${projectIds}); pass the UUID or include a \`projectId\` to disambiguate.`);
             }
-            const table = await dataTableRepository.findOneByOrFail({ id: dataTableId });
-            return { projectId: table.projectId, tableName: table.name };
+            if (projectIdFilter && result.table.projectId !== projectIdFilter) {
+                throw new Error(`Data table "${dataTableId}" does not belong to project "${projectIdFilter}".`);
+            }
+            return result.table;
+        };
+        const resolveProjectIdForTable = async (scopes, dataTableId, disambiguator) => {
+            const table = await resolveAccessibleTable(scopes, dataTableId, disambiguator);
+            return { projectId: table.projectId, resolvedId: table.id };
+        };
+        const resolveTableMeta = async (scopes, dataTableId, disambiguator) => {
+            const table = await resolveAccessibleTable(scopes, dataTableId, disambiguator);
+            return { projectId: table.projectId, tableName: table.name, resolvedId: table.id };
         };
         return {
             async list(options) {
@@ -901,14 +928,14 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     updatedAt: result.updatedAt.toISOString(),
                 };
             },
-            async delete(dataTableId) {
+            async delete(dataTableId, options) {
                 assertNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:delete'], dataTableId);
-                await dataTableService.deleteDataTable(dataTableId, projectId);
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:delete'], dataTableId, options);
+                await dataTableService.deleteDataTable(resolvedId, projectId);
             },
-            async getSchema(dataTableId) {
-                const projectId = await resolveProjectIdForTable(['dataTable:read'], dataTableId);
-                const columns = await dataTableService.getColumns(dataTableId, projectId);
+            async getSchema(dataTableId, options) {
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:read'], dataTableId, options);
+                const columns = await dataTableService.getColumns(resolvedId, projectId);
                 return columns.map((c, index) => ({
                     id: c.id,
                     name: c.name,
@@ -916,10 +943,10 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     index,
                 }));
             },
-            async addColumn(dataTableId, column) {
+            async addColumn(dataTableId, column, options) {
                 assertNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
-                const result = await dataTableService.addColumn(dataTableId, projectId, column);
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:update'], dataTableId, options);
+                const result = await dataTableService.addColumn(resolvedId, projectId, column);
                 return {
                     id: result.id,
                     name: result.name,
@@ -927,55 +954,55 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     index: result.index,
                 };
             },
-            async deleteColumn(dataTableId, columnId) {
+            async deleteColumn(dataTableId, columnId, options) {
                 assertNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
-                await dataTableService.deleteColumn(dataTableId, projectId, columnId);
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:update'], dataTableId, options);
+                await dataTableService.deleteColumn(resolvedId, projectId, columnId);
             },
-            async renameColumn(dataTableId, columnId, newName) {
+            async renameColumn(dataTableId, columnId, newName, options) {
                 assertNotReadOnly();
-                const projectId = await resolveProjectIdForTable(['dataTable:update'], dataTableId);
-                await dataTableService.renameColumn(dataTableId, projectId, columnId, {
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:update'], dataTableId, options);
+                await dataTableService.renameColumn(resolvedId, projectId, columnId, {
                     name: newName,
                 });
             },
             async queryRows(dataTableId, options) {
-                const projectId = await resolveProjectIdForTable(['dataTable:readRow'], dataTableId);
-                return await dataTableService.getManyRowsAndCount(dataTableId, projectId, {
+                const { projectId, resolvedId } = await resolveProjectIdForTable(['dataTable:readRow'], dataTableId, options);
+                return await dataTableService.getManyRowsAndCount(resolvedId, projectId, {
                     take: options?.limit ?? 50,
                     skip: options?.offset ?? 0,
                     filter: options?.filter,
                 });
             },
-            async insertRows(dataTableId, rows) {
+            async insertRows(dataTableId, rows, options) {
                 assertNotReadOnly();
-                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
-                const result = await dataTableService.insertRows(dataTableId, projectId, rows, 'count');
+                const { projectId, tableName, resolvedId } = await resolveTableMeta(['dataTable:writeRow'], dataTableId, options);
+                const result = await dataTableService.insertRows(resolvedId, projectId, rows, 'count');
                 return {
                     insertedCount: typeof result === 'number' ? result : rows.length,
-                    dataTableId,
+                    dataTableId: resolvedId,
                     tableName,
                     projectId,
                 };
             },
-            async updateRows(dataTableId, filter, data) {
+            async updateRows(dataTableId, filter, data, options) {
                 assertNotReadOnly();
-                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
-                const result = await dataTableService.updateRows(dataTableId, projectId, { filter: filter, data: data }, true);
+                const { projectId, tableName, resolvedId } = await resolveTableMeta(['dataTable:writeRow'], dataTableId, options);
+                const result = await dataTableService.updateRows(resolvedId, projectId, { filter: filter, data: data }, true);
                 return {
                     updatedCount: Array.isArray(result) ? result.length : 0,
-                    dataTableId,
+                    dataTableId: resolvedId,
                     tableName,
                     projectId,
                 };
             },
-            async deleteRows(dataTableId, filter) {
+            async deleteRows(dataTableId, filter, options) {
                 assertNotReadOnly();
-                const { projectId, tableName } = await resolveTableMeta(['dataTable:writeRow'], dataTableId);
-                const result = await dataTableService.deleteRows(dataTableId, projectId, { filter: filter }, true);
+                const { projectId, tableName, resolvedId } = await resolveTableMeta(['dataTable:writeRow'], dataTableId, options);
+                const result = await dataTableService.deleteRows(resolvedId, projectId, { filter: filter }, true);
                 return {
                     deletedCount: Array.isArray(result) ? result.length : 0,
-                    dataTableId,
+                    dataTableId: resolvedId,
                     tableName,
                     projectId,
                 };
@@ -986,6 +1013,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
         const fetchCache = this.webResearchCache;
         const searchCacheRef = this.searchCache;
         const settingsService = this.settingsService;
+        const ssrf = this.ssrfProtectionService;
         const userId = user.id;
         let resolvedSearchMethod;
         let searchResolved = false;
@@ -1019,6 +1047,7 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                     maxResponseBytes: options?.maxResponseBytes,
                     timeoutMs: options?.timeoutMs,
                     authorizeUrl: options?.authorizeUrl,
+                    ssrf,
                 });
                 const result = await (0, web_research_1.maybeSummarize)(page);
                 fetchCache.set(cacheKey, result);
@@ -1143,6 +1172,18 @@ let InstanceAiAdapterService = class InstanceAiAdapterService {
                             }
                             result.builderHint.inputs = inputs;
                         }
+                        if (n.builderHint.outputs) {
+                            const outputs = {};
+                            for (const [key, config] of Object.entries(n.builderHint.outputs)) {
+                                outputs[key] = {
+                                    ...(config.required !== undefined ? { required: config.required } : {}),
+                                    ...(config.displayOptions
+                                        ? { displayOptions: config.displayOptions }
+                                        : {}),
+                                };
+                            }
+                            result.builderHint.outputs = outputs;
+                        }
                     }
                     return result;
                 });
@@ -1569,6 +1610,7 @@ exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
         active_executions_1.ActiveExecutions,
         workflow_runner_1.WorkflowRunner,
         load_nodes_and_credentials_1.LoadNodesAndCredentials,
+        node_types_1.NodeTypes,
         n8n_core_1.InstanceSettings,
         data_table_service_1.DataTableService,
         data_table_repository_1.DataTableRepository,
@@ -1585,10 +1627,43 @@ exports.InstanceAiAdapterService = InstanceAiAdapterService = __decorate([
         event_service_1.EventService,
         role_service_1.RoleService,
         telemetry_1.Telemetry,
-        db_1.AiBuilderTemporaryWorkflowRepository])
+        db_1.AiBuilderTemporaryWorkflowRepository,
+        ssrf_protection_service_1.SsrfProtectionService])
 ], InstanceAiAdapterService);
 const MAX_RESULT_CHARS = 20_000;
 const MAX_NODE_OUTPUT_CHARS = 1_000;
+async function resolveDataTableByIdOrName(repository, logger, idOrName, options) {
+    const byId = await repository.findOneBy({ id: idOrName });
+    if (byId) {
+        if (options?.accessFilter && !(await options.accessFilter(byId.id))) {
+            return { kind: 'miss' };
+        }
+        return { kind: 'hit', table: byId };
+    }
+    const candidates = await repository.findBy({
+        name: idOrName,
+        ...(options?.projectIdFilter ? { projectId: options.projectIdFilter } : {}),
+    });
+    let filtered = candidates;
+    if (options?.accessFilter) {
+        filtered = [];
+        for (const c of candidates) {
+            if (await options.accessFilter(c.id))
+                filtered.push(c);
+        }
+    }
+    if (filtered.length === 0)
+        return { kind: 'miss' };
+    if (filtered.length > 1)
+        return { kind: 'ambiguous', candidates: filtered };
+    const hit = filtered[0];
+    logger.warn('data-tables tool called with table name instead of id — resolved by name fallback', {
+        passedValue: idOrName,
+        resolvedId: hit.id,
+        projectId: hit.projectId,
+    });
+    return { kind: 'hit', table: hit };
+}
 function findBuilderHintForMethod(nodeDesc, methodName, methodType) {
     const referencesMethod = (prop) => {
         switch (methodType) {
@@ -1685,7 +1760,8 @@ async function extractExecutionResult(executionRepository, executionId, includeO
             }
         }
     }
-    const errorMessage = execution.data?.resultData?.error?.message;
+    const error = execution.data?.resultData?.error;
+    const errorMessage = error ? formatExecutionError(error, includeOutputData) : undefined;
     return {
         executionId,
         status,
@@ -1697,6 +1773,29 @@ async function extractExecutionResult(executionRepository, executionId, includeO
         finishedAt: execution.stoppedAt?.toISOString(),
     };
 }
+const MAX_ERROR_CHARS = 4_000;
+function formatExecutionError(error, includeUpstreamDetails) {
+    const parts = [];
+    if (error.message)
+        parts.push(error.message);
+    if (includeUpstreamDetails) {
+        if (error.description && error.description !== error.message) {
+            parts.push(error.description);
+        }
+        if ('messages' in error && error.messages.length > 0) {
+            parts.push(`Details: ${error.messages.join(' | ')}`);
+        }
+    }
+    else {
+        const hasDescription = !!error.description && error.description !== error.message;
+        const hasMessages = 'messages' in error && error.messages.length > 0;
+        if (hasDescription || hasMessages) {
+            parts.push('(upstream error details suppressed by the instance AI privacy setting; ask the user to share the node error from the UI)');
+        }
+    }
+    const combined = parts.join(' — ') || 'Unknown error';
+    return combined.length > MAX_ERROR_CHARS ? `${combined.slice(0, MAX_ERROR_CHARS)}…` : combined;
+}
 const MAX_NODE_OUTPUT_BYTES = 5_000;
 function truncateNodeOutput(items) {
     const serialized = JSON.stringify(items);
@@ -1791,7 +1890,20 @@ function getExecutionModeForTrigger(node) {
             return 'manual';
     }
 }
+function validateInputDataShape(node, inputData) {
+    if (node.type === n8n_workflow_1.FORM_TRIGGER_NODE_TYPE) {
+        const formFieldsValue = inputData.formFields;
+        const looksWrapped = typeof formFieldsValue === 'object' && formFieldsValue !== null;
+        if (looksWrapped) {
+            throw new Error('verify-built-workflow: inputData for a Form Trigger must be a flat field map ' +
+                '(e.g. {name: "Alice", email: "a@b.c"}), NOT wrapped in `formFields`. ' +
+                'The production Form Trigger emits fields directly on $json, so downstream ' +
+                'expressions like $json.name are correct. Re-run with the flat shape.');
+        }
+    }
+}
 function getPinDataForTrigger(node, inputData) {
+    validateInputDataShape(node, inputData);
     switch (node.type) {
         case n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE:
             return {
@@ -1819,18 +1931,28 @@ function getPinDataForTrigger(node, inputData) {
                     },
                 ],
             };
-        case n8n_workflow_1.WEBHOOK_NODE_TYPE:
+        case n8n_workflow_1.WEBHOOK_NODE_TYPE: {
+            const envelopeKeys = new Set(['body', 'headers', 'query']);
+            const inputKeys = Object.keys(inputData);
+            const looksLikeEnvelope = inputKeys.length > 0 &&
+                inputKeys.every((k) => envelopeKeys.has(k)) &&
+                typeof inputData.body === 'object' &&
+                inputData.body !== null;
+            const body = looksLikeEnvelope ? inputData.body : inputData;
+            const headers = looksLikeEnvelope && typeof inputData.headers === 'object' && inputData.headers !== null
+                ? inputData.headers
+                : {};
+            const query = looksLikeEnvelope && typeof inputData.query === 'object' && inputData.query !== null
+                ? inputData.query
+                : {};
             return {
                 [node.name]: [
                     {
-                        json: {
-                            headers: {},
-                            query: {},
-                            body: inputData,
-                        },
+                        json: { headers, query, body },
                     },
                 ],
             };
+        }
         case n8n_workflow_1.SCHEDULE_TRIGGER_NODE_TYPE: {
             const now = new Date();
             return {
@@ -1880,24 +2002,21 @@ async function extractExecutionDebugInfo(executionRepository, executionId, inclu
             const lastRun = nodeRuns[nodeRuns.length - 1];
             if (!lastRun)
                 continue;
-            const hasError = lastRun.error !== undefined;
             const nodeType = nodeTypeMap.get(nodeName) ?? 'unknown';
             nodeTrace.push({
                 name: nodeName,
                 type: nodeType,
-                status: hasError ? 'error' : 'success',
+                status: lastRun.error !== undefined ? 'error' : 'success',
                 startedAt: lastRun.startTime !== undefined ? new Date(lastRun.startTime).toISOString() : undefined,
                 finishedAt: lastRun.startTime !== undefined && lastRun.executionTime !== undefined
                     ? new Date(lastRun.startTime + lastRun.executionTime).toISOString()
                     : undefined,
             });
-            if (hasError && !failedNode) {
+            if (lastRun.error !== undefined && !failedNode) {
                 failedNode = {
                     name: nodeName,
                     type: nodeType,
-                    error: lastRun.error instanceof Error
-                        ? lastRun.error.message
-                        : String(lastRun.error ?? 'Unknown error'),
+                    error: formatExecutionError(lastRun.error, includeOutputData),
                     inputData: includeOutputData
                         ? (() => {
                             const inputItems = lastRun.data?.main