newo 3.7.0 → 3.7.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.7.1] - 2026-04-29
+
+### Fixed
+
+- **Workflow Builder canvas blank-screen after `newo push --only attributes`** - JSON-typed project/customer attributes (e.g. `project_attributes_private_dynamic_workflow_builder_canvas`) are now always coerced to a JSON STRING when persisted to `attributes.yaml` and when sent on push. Previously, when the API returned the `value` field as a parsed object, `yaml.dump` serialized it as a YAML structure and the next push sent `{"value": {...object...}}` instead of `{"value": "...json..."}` - the platform stored a shape Builder could not render and the canvas blanked out. Change-detection now compares both sides as canonical (compact) JSON, so pretty- vs compact-printed forms and string vs object representations no longer trigger spurious pushes. String-typed values are left bit-for-bit untouched, so no churn on existing repos. New helpers in `src/sync/json-attr-utils.ts` are wired into both `src/sync/attributes.ts` and `src/domain/strategies/sync/AttributeSyncStrategy.ts`. Reported by Bob; 19 regression tests in `test/json-attribute-roundtrip.test.js`.
+
 ## [3.7.0] - 2026-04-23
 
 ### Added
@@ -1033,7 +1039,8 @@ Another Item: $Price [Modifiers: modifier3]
 - GitHub Actions CI/CD integration
 - Robust authentication with token refresh
 
-[Unreleased]: https://github.com/sabbah13/newo-cli/compare/v3.3.0...HEAD
+[Unreleased]: https://github.com/sabbah13/newo-cli/compare/v3.7.1...HEAD
+[3.7.1]: https://github.com/sabbah13/newo-cli/compare/v3.7.0...v3.7.1
 [3.3.0]: https://github.com/sabbah13/newo-cli/compare/v3.2.0...v3.3.0
 [3.2.0]: https://github.com/sabbah13/newo-cli/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/sabbah13/newo-cli/compare/v3.0.0...v3.1.0

package/dist/domain/strategies/sync/AttributeSyncStrategy.js

@@ -15,6 +15,7 @@ import path from 'path';
 import { getCustomerAttributes, getProjectAttributes, updateCustomerAttribute, updateProjectAttribute, listProjects } from '../../../api.js';
 import { writeFileSafe, customerAttributesPath, customerAttributesMapPath } from '../../../fsutil.js';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
+import { isJsonValueType, normalizeJsonValueForStorage, jsonValuesEqual } from '../../../sync/json-attr-utils.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 /**
  * AttributeSyncStrategy - Handles attribute synchronization
@@ -142,8 +143,15 @@ export class AttributeSyncStrategy {
      */
     cleanAttribute(attr) {
         let processedValue = attr.value;
-        // Handle JSON string values
-        if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+        // Coerce JSON-typed values to a STRING. The API may return parsed
+        // objects for `value_type: json`; if we let yaml.dump turn them into
+        // YAML structures, the next push sends an object and the Workflow
+        // Builder canvas blanks out. See src/sync/json-attr-utils.ts.
+        if (isJsonValueType(attr.value_type)) {
+            processedValue = normalizeJsonValueForStorage(attr.value);
+        }
+        else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            // Legacy: reformat array-of-objects JSON strings for readability
             try {
                 const parsed = JSON.parse(attr.value);
                 processedValue = JSON.stringify(parsed, null, 0);
@@ -243,10 +251,22 @@ export class AttributeSyncStrategy {
             const remoteAttr = remoteMap.get(localAttr.idn);
             if (!remoteAttr)
                 continue;
-            if (String(localAttr.value) !== String(remoteAttr.value)) {
+            // For JSON-typed attrs, compare canonical JSON (handles
+            // pretty/compact and string/object differences). Always send the
+            // value as a STRING so the platform stores the canvas the way the
+            // Workflow Builder expects to read it back.
+            const isJson = isJsonValueType(localAttr.value_type);
+            const valuesAreEqual = isJson
+                ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+                : String(localAttr.value) === String(remoteAttr.value);
+            if (!valuesAreEqual) {
+                const valueToSend = isJson
+                    ? normalizeJsonValueForStorage(localAttr.value)
+                    : localAttr.value;
                 await updateCustomerAttribute(client, {
-                    id: attributeId,
-                    ...localAttr
+                    ...localAttr,
+                    value: valueToSend,
+                    id: attributeId
                 });
                 updatedCount++;
                 this.logger.info(`  ✓ Updated customer attribute: ${localAttr.idn}`);
@@ -286,10 +306,20 @@ export class AttributeSyncStrategy {
             const remoteAttr = remoteMap.get(localAttr.idn);
             if (!remoteAttr)
                 continue;
-            if (String(localAttr.value) !== String(remoteAttr.value)) {
+            // Same canonical-JSON / always-string-on-push policy as customer
+            // attributes (see pushCustomerAttributes for rationale).
+            const isJson = isJsonValueType(localAttr.value_type);
+            const valuesAreEqual = isJson
+                ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+                : String(localAttr.value) === String(remoteAttr.value);
+            if (!valuesAreEqual) {
+                const valueToSend = isJson
+                    ? normalizeJsonValueForStorage(localAttr.value)
+                    : localAttr.value;
                 await updateProjectAttribute(client, project.id, {
-                    id: attributeId,
-                    ...localAttr
+                    ...localAttr,
+                    value: valueToSend,
+                    id: attributeId
                 });
                 updatedCount++;
                 this.logger.info(`  ✓ Updated project attribute: ${projectIdn}/${localAttr.idn}`);

package/dist/sync/attributes.js

@@ -7,6 +7,7 @@ import path from 'path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../format/yaml-patch.js';
+import { isJsonValueType, normalizeJsonValueForStorage, jsonValuesEqual } from './json-attr-utils.js';
 /**
  * Save customer attributes to YAML format and return content for hashing
  */
@@ -28,16 +29,23 @@ export async function saveCustomerAttributes(client, customer, verbose = false)
             if (attr.id) {
                 idMapping[attr.idn] = attr.id;
             }
-            // Special handling for complex JSON string values
+            // Coerce JSON-typed values to a STRING. The API can return the value
+            // as a parsed object for `value_type: json` attributes; if we let
+            // yaml.dump serialize that as a YAML structure the next push sends
+            // `{"value": {...}}` instead of `{"value": "..."}` and the Workflow
+            // Builder canvas breaks. See src/sync/json-attr-utils.ts for the
+            // full rationale.
             let processedValue = attr.value;
-            if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            if (isJsonValueType(attr.value_type)) {
+                processedValue = normalizeJsonValueForStorage(attr.value);
+            }
+            else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+                // Legacy: reformat array-of-objects JSON strings for readability
                 try {
-                    // Parse and reformat JSON for better readability
                     const parsed = JSON.parse(attr.value);
-                    processedValue = JSON.stringify(parsed, null, 0); // No extra spacing, but valid JSON
+                    processedValue = JSON.stringify(parsed, null, 0); // compact, valid JSON
                 }
                 catch (e) {
-                    // Keep original if parsing fails
                     processedValue = attr.value;
                 }
             }
@@ -114,9 +122,13 @@ export async function saveProjectAttributes(client, customer, projectId, project
             if (attr.id) {
                 idMapping[attr.idn] = attr.id;
             }
-            // Special handling for complex JSON string values
+            // Coerce JSON-typed values to a STRING. See json-attr-utils.ts for
+            // why this matters (Workflow Builder canvas blank-screen bug).
             let processedValue = attr.value;
-            if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            if (isJsonValueType(attr.value_type)) {
+                processedValue = normalizeJsonValueForStorage(attr.value);
+            }
+            else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
                 try {
                     const parsed = JSON.parse(attr.value);
                     processedValue = JSON.stringify(parsed, null, 0);
@@ -243,17 +255,31 @@ export async function pushProjectAttributes(client, customer, projectId, project
         }
         // Value type is already parsed (we removed !enum tags above)
         const valueType = localAttr.value_type;
-        // Check if value changed (use ?? to preserve 0, false, empty string)
-        const localValue = String(localAttr.value ?? '');
-        const remoteValue = String(remoteAttr.value ?? '');
-        if (localValue !== remoteValue) {
+        const isJson = isJsonValueType(valueType);
+        // Check if value changed.
+        // For JSON-typed values, compare canonical (compact) JSON so that
+        // pretty- vs compact-printed forms don't register as changes and
+        // string vs object representations compare equal. For everything
+        // else, fall back to the existing String() comparison (which still
+        // preserves 0, false, "" via ??).
+        const valuesAreEqual = isJson
+            ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+            : String(localAttr.value ?? '') === String(remoteAttr.value ?? '');
+        if (!valuesAreEqual) {
             if (verbose)
                 console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
             try {
+                // Always send JSON-typed values as a STRING. If the API or our
+                // YAML loader handed us an object, the platform stores it
+                // differently from the original string and the Workflow Builder
+                // canvas blanks out.
+                const valueToSend = isJson
+                    ? normalizeJsonValueForStorage(localAttr.value)
+                    : localAttr.value;
                 const attributeToUpdate = {
                     id: attributeId,
                     idn: localAttr.idn,
-                    value: localAttr.value,
+                    value: valueToSend,
                     title: localAttr.title,
                     description: localAttr.description,
                     group: localAttr.group,

package/dist/sync/json-attr-utils.d.ts

@@ -0,0 +1,67 @@
+/**
+ * JSON-typed attribute helpers.
+ *
+ * Why this exists:
+ *
+ * The NEWO platform stores some attributes (e.g.
+ * `project_attributes_private_dynamic_workflow_builder_canvas`) as
+ * `value_type: json`. The API may return the `value` field as either a
+ * STRING containing JSON or as an already-parsed OBJECT.
+ *
+ * Without normalization, two bugs leak through:
+ *
+ * 1. When the API returns the value as an OBJECT, `yaml.dump` serializes
+ *    it as a YAML structure (mappings/sequences). Pushing back then sends
+ *    `{"value": {...}}` instead of `{"value": "..."}`, breaking the
+ *    Workflow Builder which expects the canvas as a JSON STRING.
+ *
+ * 2. The push-time change check used `String(localAttr.value)` for
+ *    comparison. With objects this collapses to `"[object Object]"` on
+ *    both sides — silently masking real changes — and with mismatched
+ *    string vs object representations it triggers spurious pushes that
+ *    overwrite the canvas with the wrong shape (Builder shows blank).
+ *
+ * The fix is conservative: for `value_type: json` only, always coerce the
+ * value to a STRING when persisting and when pushing, and use canonical
+ * JSON for comparisons. String-typed values in the wild are left
+ * untouched, so no churn for the majority of attributes.
+ */
+/**
+ * True if the attribute is a JSON-typed attribute (case- and
+ * format-insensitive: handles `json`, `JSON`, `AttributeValueTypes.json`,
+ * `ValueType.JSON`, etc.).
+ */
+export declare function isJsonValueType(valueType: unknown): boolean;
+/**
+ * Coerce a JSON-typed attribute's value to a STRING suitable for storage
+ * in attributes.yaml and for sending to the platform.
+ *
+ * - `null` / `undefined` → `''`
+ * - object → compact JSON string (`JSON.stringify(value)`)
+ * - string → returned as-is (we trust the platform's existing format)
+ * - other → `String(value)`
+ *
+ * We deliberately do NOT re-format string values, even when they look
+ * like JSON. Many existing canvases are stored pretty-printed and
+ * reformatting would create huge spurious diffs in users' repos.
+ */
+export declare function normalizeJsonValueForStorage(value: unknown): string;
+/**
+ * Canonical comparison for JSON-typed attribute values.
+ *
+ * Returns the canonical form (compact JSON if parseable, otherwise the
+ * raw string). Use this on both sides of a comparison so that pretty- vs
+ * compact-printed JSON does not register as a change, and so that an
+ * object on one side equals its stringified form on the other side.
+ */
+export declare function canonicalJsonValue(value: unknown): string;
+/**
+ * True if two JSON-typed attribute values are semantically equal.
+ *
+ * Handles the four mismatched representations that can occur during a
+ * pull/push cycle:
+ *   string vs string (different whitespace/indent), object vs string,
+ *   string vs object, object vs object.
+ */
+export declare function jsonValuesEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=json-attr-utils.d.ts.map

package/dist/sync/json-attr-utils.js

@@ -0,0 +1,98 @@
+/**
+ * JSON-typed attribute helpers.
+ *
+ * Why this exists:
+ *
+ * The NEWO platform stores some attributes (e.g.
+ * `project_attributes_private_dynamic_workflow_builder_canvas`) as
+ * `value_type: json`. The API may return the `value` field as either a
+ * STRING containing JSON or as an already-parsed OBJECT.
+ *
+ * Without normalization, two bugs leak through:
+ *
+ * 1. When the API returns the value as an OBJECT, `yaml.dump` serializes
+ *    it as a YAML structure (mappings/sequences). Pushing back then sends
+ *    `{"value": {...}}` instead of `{"value": "..."}`, breaking the
+ *    Workflow Builder which expects the canvas as a JSON STRING.
+ *
+ * 2. The push-time change check used `String(localAttr.value)` for
+ *    comparison. With objects this collapses to `"[object Object]"` on
+ *    both sides — silently masking real changes — and with mismatched
+ *    string vs object representations it triggers spurious pushes that
+ *    overwrite the canvas with the wrong shape (Builder shows blank).
+ *
+ * The fix is conservative: for `value_type: json` only, always coerce the
+ * value to a STRING when persisting and when pushing, and use canonical
+ * JSON for comparisons. String-typed values in the wild are left
+ * untouched, so no churn for the majority of attributes.
+ */
+/**
+ * True if the attribute is a JSON-typed attribute (case- and
+ * format-insensitive: handles `json`, `JSON`, `AttributeValueTypes.json`,
+ * `ValueType.JSON`, etc.).
+ */
+export function isJsonValueType(valueType) {
+    if (typeof valueType !== 'string')
+        return false;
+    const lower = valueType.toLowerCase();
+    return lower === 'json' || lower.endsWith('.json');
+}
+/**
+ * Coerce a JSON-typed attribute's value to a STRING suitable for storage
+ * in attributes.yaml and for sending to the platform.
+ *
+ * - `null` / `undefined` → `''`
+ * - object → compact JSON string (`JSON.stringify(value)`)
+ * - string → returned as-is (we trust the platform's existing format)
+ * - other → `String(value)`
+ *
+ * We deliberately do NOT re-format string values, even when they look
+ * like JSON. Many existing canvases are stored pretty-printed and
+ * reformatting would create huge spurious diffs in users' repos.
+ */
+export function normalizeJsonValueForStorage(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Canonical comparison for JSON-typed attribute values.
+ *
+ * Returns the canonical form (compact JSON if parseable, otherwise the
+ * raw string). Use this on both sides of a comparison so that pretty- vs
+ * compact-printed JSON does not register as a change, and so that an
+ * object on one side equals its stringified form on the other side.
+ */
+export function canonicalJsonValue(value) {
+    const stringified = normalizeJsonValueForStorage(value);
+    if (stringified === '')
+        return '';
+    try {
+        return JSON.stringify(JSON.parse(stringified));
+    }
+    catch {
+        return stringified;
+    }
+}
+/**
+ * True if two JSON-typed attribute values are semantically equal.
+ *
+ * Handles the four mismatched representations that can occur during a
+ * pull/push cycle:
+ *   string vs string (different whitespace/indent), object vs string,
+ *   string vs object, object vs object.
+ */
+export function jsonValuesEqual(a, b) {
+    return canonicalJsonValue(a) === canonicalJsonValue(b);
+}
+//# sourceMappingURL=json-attr-utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.7.0",
+  "version": "3.7.1",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/domain/strategies/sync/AttributeSyncStrategy.ts

@@ -39,6 +39,11 @@ import {
   customerAttributesMapPath
 } from '../../../fsutil.js';
 import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
+import {
+  isJsonValueType,
+  normalizeJsonValueForStorage,
+  jsonValuesEqual
+} from '../../../sync/json-attr-utils.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 
 /**
@@ -220,8 +225,14 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
   private cleanAttribute(attr: CustomerAttribute): CustomerAttribute {
     let processedValue = attr.value;
 
-    // Handle JSON string values
-    if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+    // Coerce JSON-typed values to a STRING. The API may return parsed
+    // objects for `value_type: json`; if we let yaml.dump turn them into
+    // YAML structures, the next push sends an object and the Workflow
+    // Builder canvas blanks out. See src/sync/json-attr-utils.ts.
+    if (isJsonValueType(attr.value_type)) {
+      processedValue = normalizeJsonValueForStorage(attr.value);
+    } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      // Legacy: reformat array-of-objects JSON strings for readability
       try {
         const parsed = JSON.parse(attr.value);
         processedValue = JSON.stringify(parsed, null, 0);
@@ -342,10 +353,24 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
       const remoteAttr = remoteMap.get(localAttr.idn);
       if (!remoteAttr) continue;
 
-      if (String(localAttr.value) !== String(remoteAttr.value)) {
+      // For JSON-typed attrs, compare canonical JSON (handles
+      // pretty/compact and string/object differences). Always send the
+      // value as a STRING so the platform stores the canvas the way the
+      // Workflow Builder expects to read it back.
+      const isJson = isJsonValueType(localAttr.value_type);
+      const valuesAreEqual = isJson
+        ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+        : String(localAttr.value) === String(remoteAttr.value);
+
+      if (!valuesAreEqual) {
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         await updateCustomerAttribute(client, {
-          id: attributeId,
-          ...localAttr
+          ...localAttr,
+          value: valueToSend,
+          id: attributeId
         });
         updatedCount++;
         this.logger.info(`  ✓ Updated customer attribute: ${localAttr.idn}`);
@@ -399,10 +424,22 @@ export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesRe
       const remoteAttr = remoteMap.get(localAttr.idn);
       if (!remoteAttr) continue;
 
-      if (String(localAttr.value) !== String(remoteAttr.value)) {
+      // Same canonical-JSON / always-string-on-push policy as customer
+      // attributes (see pushCustomerAttributes for rationale).
+      const isJson = isJsonValueType(localAttr.value_type);
+      const valuesAreEqual = isJson
+        ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+        : String(localAttr.value) === String(remoteAttr.value);
+
+      if (!valuesAreEqual) {
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         await updateProjectAttribute(client, project.id, {
-          id: attributeId,
-          ...localAttr
+          ...localAttr,
+          value: valueToSend,
+          id: attributeId
         });
         updatedCount++;
         this.logger.info(`  ✓ Updated project attribute: ${projectIdn}/${localAttr.idn}`);

package/src/sync/attributes.ts

@@ -12,6 +12,11 @@ import path from 'path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../format/yaml-patch.js';
+import {
+  isJsonValueType,
+  normalizeJsonValueForStorage,
+  jsonValuesEqual
+} from './json-attr-utils.js';
 import type { AxiosInstance } from 'axios';
 import type { CustomerConfig } from '../types.js';
 
@@ -43,15 +48,21 @@ export async function saveCustomerAttributes(
         idMapping[attr.idn] = attr.id;
       }
 
-      // Special handling for complex JSON string values
+      // Coerce JSON-typed values to a STRING. The API can return the value
+      // as a parsed object for `value_type: json` attributes; if we let
+      // yaml.dump serialize that as a YAML structure the next push sends
+      // `{"value": {...}}` instead of `{"value": "..."}` and the Workflow
+      // Builder canvas breaks. See src/sync/json-attr-utils.ts for the
+      // full rationale.
       let processedValue = attr.value;
-      if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      if (isJsonValueType(attr.value_type)) {
+        processedValue = normalizeJsonValueForStorage(attr.value);
+      } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+        // Legacy: reformat array-of-objects JSON strings for readability
         try {
-          // Parse and reformat JSON for better readability
           const parsed = JSON.parse(attr.value);
-          processedValue = JSON.stringify(parsed, null, 0); // No extra spacing, but valid JSON
+          processedValue = JSON.stringify(parsed, null, 0); // compact, valid JSON
         } catch (e) {
-          // Keep original if parsing fails
           processedValue = attr.value;
         }
       }
@@ -145,9 +156,12 @@ export async function saveProjectAttributes(
         idMapping[attr.idn] = attr.id;
       }
 
-      // Special handling for complex JSON string values
+      // Coerce JSON-typed values to a STRING. See json-attr-utils.ts for
+      // why this matters (Workflow Builder canvas blank-screen bug).
       let processedValue = attr.value;
-      if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      if (isJsonValueType(attr.value_type)) {
+        processedValue = normalizeJsonValueForStorage(attr.value);
+      } else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
         try {
           const parsed = JSON.parse(attr.value);
           processedValue = JSON.stringify(parsed, null, 0);
@@ -297,19 +311,34 @@ export async function pushProjectAttributes(
 
     // Value type is already parsed (we removed !enum tags above)
     const valueType = localAttr.value_type;
-
-    // Check if value changed (use ?? to preserve 0, false, empty string)
-    const localValue = String(localAttr.value ?? '');
-    const remoteValue = String(remoteAttr.value ?? '');
-
-    if (localValue !== remoteValue) {
+    const isJson = isJsonValueType(valueType);
+
+    // Check if value changed.
+    // For JSON-typed values, compare canonical (compact) JSON so that
+    // pretty- vs compact-printed forms don't register as changes and
+    // string vs object representations compare equal. For everything
+    // else, fall back to the existing String() comparison (which still
+    // preserves 0, false, "" via ??).
+    const valuesAreEqual = isJson
+      ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+      : String(localAttr.value ?? '') === String(remoteAttr.value ?? '');
+
+    if (!valuesAreEqual) {
       if (verbose) console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
 
       try {
+        // Always send JSON-typed values as a STRING. If the API or our
+        // YAML loader handed us an object, the platform stores it
+        // differently from the original string and the Workflow Builder
+        // canvas blanks out.
+        const valueToSend = isJson
+          ? normalizeJsonValueForStorage(localAttr.value)
+          : localAttr.value;
+
         const attributeToUpdate = {
           id: attributeId,
           idn: localAttr.idn,
-          value: localAttr.value,
+          value: valueToSend,
           title: localAttr.title,
           description: localAttr.description,
           group: localAttr.group,

package/src/sync/json-attr-utils.ts

@@ -0,0 +1,95 @@
+/**
+ * JSON-typed attribute helpers.
+ *
+ * Why this exists:
+ *
+ * The NEWO platform stores some attributes (e.g.
+ * `project_attributes_private_dynamic_workflow_builder_canvas`) as
+ * `value_type: json`. The API may return the `value` field as either a
+ * STRING containing JSON or as an already-parsed OBJECT.
+ *
+ * Without normalization, two bugs leak through:
+ *
+ * 1. When the API returns the value as an OBJECT, `yaml.dump` serializes
+ *    it as a YAML structure (mappings/sequences). Pushing back then sends
+ *    `{"value": {...}}` instead of `{"value": "..."}`, breaking the
+ *    Workflow Builder which expects the canvas as a JSON STRING.
+ *
+ * 2. The push-time change check used `String(localAttr.value)` for
+ *    comparison. With objects this collapses to `"[object Object]"` on
+ *    both sides — silently masking real changes — and with mismatched
+ *    string vs object representations it triggers spurious pushes that
+ *    overwrite the canvas with the wrong shape (Builder shows blank).
+ *
+ * The fix is conservative: for `value_type: json` only, always coerce the
+ * value to a STRING when persisting and when pushing, and use canonical
+ * JSON for comparisons. String-typed values in the wild are left
+ * untouched, so no churn for the majority of attributes.
+ */
+
+/**
+ * True if the attribute is a JSON-typed attribute (case- and
+ * format-insensitive: handles `json`, `JSON`, `AttributeValueTypes.json`,
+ * `ValueType.JSON`, etc.).
+ */
+export function isJsonValueType(valueType: unknown): boolean {
+  if (typeof valueType !== 'string') return false;
+  const lower = valueType.toLowerCase();
+  return lower === 'json' || lower.endsWith('.json');
+}
+
+/**
+ * Coerce a JSON-typed attribute's value to a STRING suitable for storage
+ * in attributes.yaml and for sending to the platform.
+ *
+ * - `null` / `undefined` → `''`
+ * - object → compact JSON string (`JSON.stringify(value)`)
+ * - string → returned as-is (we trust the platform's existing format)
+ * - other → `String(value)`
+ *
+ * We deliberately do NOT re-format string values, even when they look
+ * like JSON. Many existing canvases are stored pretty-printed and
+ * reformatting would create huge spurious diffs in users' repos.
+ */
+export function normalizeJsonValueForStorage(value: unknown): string {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+
+/**
+ * Canonical comparison for JSON-typed attribute values.
+ *
+ * Returns the canonical form (compact JSON if parseable, otherwise the
+ * raw string). Use this on both sides of a comparison so that pretty- vs
+ * compact-printed JSON does not register as a change, and so that an
+ * object on one side equals its stringified form on the other side.
+ */
+export function canonicalJsonValue(value: unknown): string {
+  const stringified = normalizeJsonValueForStorage(value);
+  if (stringified === '') return '';
+  try {
+    return JSON.stringify(JSON.parse(stringified));
+  } catch {
+    return stringified;
+  }
+}
+
+/**
+ * True if two JSON-typed attribute values are semantically equal.
+ *
+ * Handles the four mismatched representations that can occur during a
+ * pull/push cycle:
+ *   string vs string (different whitespace/indent), object vs string,
+ *   string vs object, object vs object.
+ */
+export function jsonValuesEqual(a: unknown, b: unknown): boolean {
+  return canonicalJsonValue(a) === canonicalJsonValue(b);
+}