czlonkowski
diff --git a/‎CHANGELOG.md‎
Lines changed: 16 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎package-lock.json‎
Lines changed: 2 additions & 2 deletions b/‎package-lock.json‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎package.json‎
Lines changed: 1 addition & 1 deletion b/‎package.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎package.runtime.json‎
Lines changed: 1 addition & 1 deletion b/‎package.runtime.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎scripts/check-settings-drift.ts‎
Lines changed: 57 additions & 9 deletions b/‎scripts/check-settings-drift.ts‎
Lines changed: 57 additions & 9 deletions
diff --git a/‎src/database/shared-database.ts‎
Lines changed: 0 additions & 2 deletions b/‎src/database/shared-database.ts‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎src/http-server-single-session.ts‎
Lines changed: 1 addition & 1 deletion b/‎src/http-server-single-session.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/mcp-engine.ts‎
Lines changed: 3 additions & 2 deletions b/‎src/mcp-engine.ts‎
Lines changed: 3 additions & 2 deletions
diff --git a/‎src/mcp/handlers-workflow-diff.ts‎
Lines changed: 63 additions & 7 deletions b/‎src/mcp/handlers-workflow-diff.ts‎
Lines changed: 63 additions & 7 deletions
@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.81.0] - 2026-09-03
+
+### Added
+
+- **Workflow writes retry without the settings an n8n instance rejects as unknown.** Settings are forwarded untouched on purpose, because the bundled settings table trails n8n's releases and a property dropped up front is dropped silently. The cost was that a setting the instance's write schema does not accept failed the whole write with `request/body/settings must NOT have additional properties`, a message that never names the key, which is what users hit when a GET echoes a property such as `timeSavedMode` that their n8n version stores but does not accept on PUT ([#1017](https://github.com/czlonkowski/n8n-mcp/pull/1017)). The API client now retries without candidates in a fixed order: keys absent from the settings table first, together, then known keys from newest to oldest; keys that predate n8n 1.119.0 are never dropped, since instances that old still report their version and are filtered precisely. Each dropped key is reported in the tool response `warnings` and remembered for the client's lifetime so later writes skip the probe. `timeSavedMode` itself stays writable: n8n 2.36 accepts and echoes it, so marking it derived would have dropped a real setting on current instances.
+
+### Fixed
+
+- **Node properties that n8n echoes on GET but rejects on PUT are stripped before a write** ([#983](https://github.com/czlonkowski/n8n-mcp/pull/983)). n8n's node schema is `additionalProperties: false`, and a GET can carry `issues`, `runIndex` or `data`, so a round trip failed with `request/body/nodes/0 must NOT have additional properties`. `cleanWorkflowForCreate` and `cleanWorkflowForUpdate` now keep only the properties of the node schema; the allowlist is derived from that schema, so it cannot drift from it. `onError` and `webhookId` were missing from the schema and are accepted.
+- **A rollback that n8n persisted before rejecting is no longer reported as failed** ([#979](https://github.com/czlonkowski/n8n-mcp/pull/979)). n8n's public API can commit workflow content and then throw on a later check, so `n8n_update_partial_workflow` could warn that a workflow was left broken when it had in fact been restored. After a rollback PUT throws, the handler re-reads the workflow and compares the writable fields with the pre-update snapshot; a match is reported as `rollbackVerifiedAfterError: true`. Webhook ids generated for the comparison are ignored; ids the workflow already carried are compared.
+- **Engine health check reported a hard-coded version** ([#908](https://github.com/czlonkowski/n8n-mcp/pull/908)). `N8NMCPEngine.healthCheck()` returned `2.24.1` regardless of the installed version; it now reports the package version. The HTTP server's response logging reads `writableEnded` instead of the deprecated `finished`.
+
+### Changed
+
+- Round-trip tests for GET→UPDATE workflow writes ([#925](https://github.com/czlonkowski/n8n-mcp/pull/925), [#433](https://github.com/czlonkowski/n8n-mcp/issues/433)): unit tests for the cleaners and integration tests against a live instance for the spread-a-GET-into-an-update patterns the n8n API is particular about.
+
 ## [2.80.1] - 2026-09-03
 
 ### Fixed
 
@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.80.1",
+  "version": "2.81.0",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
 
@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.80.1",
+  "version": "2.81.0",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "dependencies": {
 
@@ -21,9 +21,12 @@ import {
   WORKFLOW_SETTINGS_PROPERTIES,
   type SettingsVersion,
 } from '../src/constants/workflow-settings';
+import { WRITABLE_NODE_PROPERTIES } from '../src/services/n8n-validation';
 
 const SCHEMA_PATH = 'dist/public-api/v1/openapi.yml';
 const SCHEMA_NAME = 'workflowSettings';
+/** The node schema is `additionalProperties: false` too; cleanNodeForApi strips to WRITABLE_NODE_PROPERTIES. */
+const NODE_SCHEMA_NAME = 'node';
 const ENTITY_INTERFACE = 'IWorkflowSettings';
 
 function resolveVersion(): string {
@@ -70,13 +73,17 @@ const indentOf = (line: string): number => line.length - line.trimStart().length
  * this cannot find throws, which is the point - a silently empty result would read as "no
  * drift".
  */
-export function parseSchemaProperties(yaml: string): Set<string> {
+export function parseSchemaProperties(
+  yaml: string,
+  schemaName = SCHEMA_NAME,
+  readOnly?: Set<string>
+): Set<string> {
   const lines = yaml.split('\n');
 
-  const schemaIndex = lines.findIndex(line => new RegExp(`^\\s+${SCHEMA_NAME}:\\s*$`).test(line));
+  const schemaIndex = lines.findIndex(line => new RegExp(`^\\s+${schemaName}:\\s*$`).test(line));
   if (schemaIndex === -1) {
     throw new Error(
-      `No "${SCHEMA_NAME}:" schema in ${SCHEMA_PATH}. n8n may have renamed it - check the spec.`
+      `No "${schemaName}:" schema in ${SCHEMA_PATH}. n8n may have renamed it - check the spec.`
     );
   }
   const schemaIndent = indentOf(lines[schemaIndex]);
@@ -94,12 +101,14 @@ export function parseSchemaProperties(yaml: string): Set<string> {
     }
   }
   if (propertiesIndex === -1) {
-    throw new Error(`"${SCHEMA_NAME}" has no properties block in ${SCHEMA_PATH}`);
+    throw new Error(`"${schemaName}" has no properties block in ${SCHEMA_PATH}`);
   }
 
   const propertiesIndent = indentOf(lines[propertiesIndex]);
   const names = new Set<string>();
   let keyIndent: number | null = null;
+  let current: string | null = null;
+  let readOnlyIndent: number | null = null;
 
   for (let i = propertiesIndex + 1; i < lines.length; i++) {
     const line = lines[i];
@@ -108,18 +117,42 @@ export function parseSchemaProperties(yaml: string): Set<string> {
     if (indent <= propertiesIndent) break;
 
     if (keyIndent === null) keyIndent = indent;
-    if (indent !== keyIndent) continue; // nested schema of the property above
+    if (indent !== keyIndent) {
+      // Directly under the property above, `readOnly: true` marks a GET-only property. Deeper
+      // lines belong to a sub-schema and say nothing about the property itself.
+      if (current && indent > keyIndent && line.trim() === 'readOnly: true' && readOnlyIndent === indent) {
+        readOnly?.add(current);
+      }
+      continue;
+    }
 
     const match = line.trim().match(/^([A-Za-z][A-Za-z0-9_]*):/);
+    current = match ? match[1] : null;
     if (match) names.add(match[1]);
+    // The property's own attributes sit one level in; measured from the next line, not assumed.
+    readOnlyIndent = lines.slice(i + 1).find(next => next.trim() !== '')?.match(/^\s*/)?.[0].length ?? null;
   }
 
   if (names.size === 0) {
-    throw new Error(`Parsed zero properties from "${SCHEMA_NAME}" - the spec format changed`);
+    throw new Error(`Parsed zero properties from "${schemaName}" - the spec format changed`);
   }
   return names;
 }
 
+/**
+ * Node-level drift: properties the node write schema accepts that cleanNodeForApi would strip,
+ * and properties we send that the schema no longer lists. Read-only ones (createdAt, updatedAt)
+ * are rejected on write, so stripping them is correct and they are not reported.
+ */
+export function diffNodeProperties(yaml: string): { missing: string[]; removed: string[] } {
+  const readOnly = new Set<string>();
+  const schema = parseSchemaProperties(yaml, NODE_SCHEMA_NAME, readOnly);
+  return {
+    missing: [...schema].filter(name => !readOnly.has(name) && !WRITABLE_NODE_PROPERTIES.has(name)),
+    removed: [...WRITABLE_NODE_PROPERTIES].filter(name => !schema.has(name)),
+  };
+}
+
 /**
  * Pull the property names out of n8n-workflow's `IWorkflowSettings` declaration - the workflow
  * entity's settings type, which the Public API schema is supposed to mirror but has trailed
@@ -426,7 +459,9 @@ async function main(): Promise<void> {
     }
   }
 
-  const schemaProperties = parseSchemaProperties(await fetchSchemaFile(version));
+  const schemaYaml = await fetchSchemaFile(version);
+  const schemaProperties = parseSchemaProperties(schemaYaml);
+  const nodeDrift = diffNodeProperties(schemaYaml);
 
   const { missing, removed, ahead, entityOnly, unhandledEntityOnly, publishedEntityOnly } =
     diffSettingsProperties(schemaProperties, entityProperties, parseVersion(version));
@@ -443,13 +478,26 @@ async function main(): Promise<void> {
     console.log(`ℹ️  ${entityOnly.length} entity-only, stripped on write (expected): ${entityOnly.join(', ')}\n`);
   }
 
+  if (nodeDrift.missing.length > 0) {
+    console.error(`❌ ${nodeDrift.missing.length} node property/properties in n8n's write schema that cleanNodeForApi strips:`);
+    for (const name of nodeDrift.missing) console.error(`   + ${name}`);
+    console.error('\n   Add each to workflowNodeObjectSchema in src/services/n8n-validation.ts.\n');
+  }
+  if (nodeDrift.removed.length > 0) {
+    console.error(`❌ ${nodeDrift.removed.length} node property/properties we send that n8n's write schema no longer lists:`);
+    for (const name of nodeDrift.removed) console.error(`   - ${name}`);
+    console.error('\n   Remove them from workflowNodeObjectSchema once no supported version accepts them.\n');
+  }
+
   if (
     missing.length === 0 &&
     removed.length === 0 &&
     unhandledEntityOnly.length === 0 &&
-    publishedEntityOnly.length === 0
+    publishedEntityOnly.length === 0 &&
+    nodeDrift.missing.length === 0 &&
+    nodeDrift.removed.length === 0
   ) {
-    console.log('✅ No drift - src/constants/workflow-settings.ts matches n8n.');
+    console.log('✅ No drift - src/constants/workflow-settings.ts and the node schema match n8n.');
     return;
   }
 
 
@@ -7,8 +7,6 @@
  *
  * Memory impact: Reduces per-session memory from ~900MB to near-zero by sharing
  * a single ~68MB database connection across all sessions.
- *
- * Issue: https://github.com/czlonkowski/n8n-mcp/issues/XXX
  */
 
 import path from 'path';
 
@@ -1630,7 +1630,7 @@ export class SingleSessionHTTPServer {
       logger.info('POST /mcp request completed - checking response status', {
         responseHeadersSent: res.headersSent,
         responseStatusCode: res.statusCode,
-        responseFinished: res.finished
+        responseFinished: res.writableEnded
       });
     });
 
 
@@ -8,6 +8,7 @@
 import { Request, Response } from 'express';
 import { SingleSessionHTTPServer } from './http-server-single-session';
 import { logger } from './utils/logger';
+import { PROJECT_VERSION } from './utils/version';
 import { InstanceContext } from './types/instance-context';
 import { SessionState } from './types/session-state';
 import type { AdditionalTool } from './types/additional-tools';
@@ -105,7 +106,7 @@ export class N8NMCPEngine {
           total: Math.round(memoryUsage.heapTotal / 1024 / 1024),
           unit: 'MB'
         },
-        version: '2.24.1'
+        version: PROJECT_VERSION
       };
     } catch (error) {
       logger.error('Health check failed:', error);
@@ -114,7 +115,7 @@ export class N8NMCPEngine {
         uptime: 0,
         sessionActive: false,
         memoryUsage: { used: 0, total: 0, unit: 'MB' },
-        version: '2.24.1'
+        version: PROJECT_VERSION
       };
     }
   }
 
@@ -5,14 +5,15 @@
 
 import { z } from 'zod';
 import { randomUUID } from 'crypto';
-import { McpToolResponse } from '../types/n8n-api';
+import { isDeepStrictEqual } from 'node:util';
+import { McpToolResponse, Workflow } from '../types/n8n-api';
 import { WorkflowDiffRequest, WorkflowDiffOperation, WorkflowDiffValidationError } from '../types/workflow-diff';
 import { WorkflowDiffEngine } from '../services/workflow-diff-engine';
 import { getN8nApiClient } from './handlers-n8n-manager';
 import { N8nApiError, getUserFriendlyErrorMessage } from '../utils/n8n-errors';
 import { logger } from '../utils/logger';
 import { InstanceContext, getInstanceScopeId } from '../types/instance-context';
-import { validateWorkflowStructure } from '../services/n8n-validation';
+import { validateWorkflowStructure, cleanWorkflowForUpdate } from '../services/n8n-validation';
 import { NodeRepository } from '../database/node-repository';
 import { WorkflowVersioningService } from '../services/workflow-versioning-service';
 import { WorkflowValidator } from '../services/workflow-validator';
@@ -48,6 +49,38 @@ function compareVersions(
   return 'unknown';
 }
 
+// Ids of nodes that lack a webhookId in the given read. cleanWorkflowForUpdate() assigns a random
+// one to such nodes, and the server persists it, so the snapshot taken before a write and the read
+// taken after it legitimately differ there. A webhookId both reads carry is real content.
+function nodesWithoutWebhookId(workflow: Workflow): string[] {
+  return (workflow.nodes ?? []).filter(node => node.id && !node.webhookId).map(node => node.id);
+}
+
+// The shape an update would send, for comparing two reads of the same workflow. Cloned because
+// cleanWorkflowForUpdate() mutates its input.
+function writableShape(workflow: Workflow, ignoreWebhookIdOf: Set<string>): Record<string, unknown> {
+  const cleaned = cleanWorkflowForUpdate(structuredClone(workflow)) as Record<string, unknown>;
+  if (Array.isArray(cleaned.nodes)) {
+    for (const node of cleaned.nodes) {
+      if (ignoreWebhookIdOf.has(node.id)) delete node.webhookId;
+    }
+  }
+  return cleaned;
+}
+
+// Compare only the fields the update allowlist accepts. Version identity cannot verify a rollback:
+// a successful rollback writes a new version, so compareVersions() reports 'changed' regardless.
+// Generated webhook ids are ignored on both sides whichever read lacks them, so the outcome does
+// not depend on whether an earlier write mutated the snapshot in place.
+function sameWritableContent(a: Workflow, b: Workflow): boolean {
+  try {
+    const generated = new Set([...nodesWithoutWebhookId(a), ...nodesWithoutWebhookId(b)]);
+    return isDeepStrictEqual(writableShape(a, generated), writableShape(b, generated));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Get or create cached workflow validator instance
  * Reuses the same validator to avoid redundant NodeSimilarityService initialization
@@ -422,6 +455,7 @@ export async function handleUpdatePartialWorkflow(
 
           // Either persist-then-fail OR couldn't determine — attempt rollback.
           let rollbackPerformed = false;
+          let rollbackVerifiedAfterError = false;
           let rollbackErrorMessage: string | undefined;
           try {
             // No authoredGroups here: restoring the graph matters, frames do not. If the snapshot's
@@ -436,11 +470,32 @@ export async function handleUpdatePartialWorkflow(
             });
           } catch (rollbackErr) {
             rollbackErrorMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
-            logger.error('updateWorkflow failed AND rollback failed', {
-              workflowId: input.id,
-              originalError: updateError instanceof Error ? updateError.message : String(updateError),
-              rollbackError: rollbackErrorMessage,
-            });
+
+            // n8n can persist a rollback PUT and then reject it: the public API commits workflow
+            // content before it checks publish permission. Verify against the server rather than
+            // trusting the throw, or we warn of a broken workflow that was in fact restored.
+            try {
+              const afterRollback = await client.getWorkflow(input.id);
+              if (sameWritableContent(afterRollback, workflowBefore)) {
+                rollbackPerformed = true;
+                rollbackVerifiedAfterError = true;
+                logger.warn('rollback PUT errored but content matches the prior state; treating as rolled back', {
+                  workflowId: input.id,
+                  rollbackError: rollbackErrorMessage,
+                });
+                rollbackErrorMessage = undefined;
+              }
+            } catch (verifyErr) {
+              logger.debug('post-rollback verification GET failed', verifyErr);
+            }
+
+            if (!rollbackPerformed) {
+              logger.error('updateWorkflow failed AND rollback failed', {
+                workflowId: input.id,
+                originalError: updateError instanceof Error ? updateError.message : String(updateError),
+                rollbackError: rollbackErrorMessage,
+              });
+            }
           }
 
           // Re-throw with rollback context attached so the outer N8nApiError
@@ -454,6 +509,7 @@ export async function handleUpdatePartialWorkflow(
             const augmentedDetails: Record<string, unknown> = {
               ...((updateError.details as Record<string, unknown>) ?? {}),
               rollbackPerformed,
+              ...(rollbackVerifiedAfterError ? { rollbackVerifiedAfterError: true } : {}),
               ...(folderMoveInPayload && rollbackPerformed ? { folderMoveMayHavePersisted: true } : {}),
               ...(rollbackErrorMessage ? { rollbackError: rollbackErrorMessage } : {}),
               ...(workflowBefore.versionId ? { priorVersionId: workflowBefore.versionId } : {}),
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "n8n-mcp",`
`3`		`- "version": "2.80.1",`
	`3`	`+ "version": "2.81.0",`
`4`	`4`	`"description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",`
`5`	`5`	`"main": "dist/index.js",`
`6`	`6`	`"types": "dist/index.d.ts",`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "n8n-mcp-runtime",`
`3`		`- "version": "2.80.1",`
	`3`	`+ "version": "2.81.0",`
`4`	`4`	`"description": "n8n MCP Server Runtime Dependencies Only",`
`5`	`5`	`"private": true,`
`6`	`6`	`"dependencies": {`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,6 @@`
`7`	`7`	`*`
`8`	`8`	`* Memory impact: Reduces per-session memory from ~900MB to near-zero by sharing`
`9`	`9`	`* a single ~68MB database connection across all sessions.`
`10`		`- *`
`11`		`- * Issue: https://github.com/czlonkowski/n8n-mcp/issues/XXX`
`12`	`10`	`*/`
`13`	`11`
`14`	`12`	`import path from 'path';`