@flowfuse/nr-assistant 0.14.0 → 0.14.1-5d7a461-202605121018.0

package/CHANGELOG.md

@@ -1,3 +1,5 @@
+# CHANGELOG
+
 ## [0.14.0](https://github.com/FlowFuse/nr-assistant/compare/v0.13.1...v0.14.0) (2026-05-07)
 
  - feat(actions): add automation/open-palette-manager action (#314) @andypalmi
@@ -10,7 +12,7 @@
  - chore(deps): bump hono from 4.12.14 to 4.12.18 (#308) @app/dependabot
  - build(deps): bump protobufjs from 7.5.3 to 7.5.5 (#272) @app/dependabot
 
-## 0.13.0
+## [0.13.0](https://github.com/FlowFuse/nr-assistant/compare/v0.12.0...v0.13.0) (2026-05-06)
 
  - ci: Use new project-automation workflow (#303)
  - ci: Replace PAT with GitHub Application token in `Projects automations` workflow (#300)
@@ -53,7 +55,7 @@
  - Update lint scripts to include all subdirectories (#255) @Steve-Mcl
  - Use git ref_name for version instead of npm info (#252) @allthedoll
 
-## 0.12.0
+## [0.12.0](https://github.com/FlowFuse/nr-assistant/compare/v0.11.0...v0.12.0) (2026-04-08)
 
  - Bump actions/create-github-app-token from 2.2.1 to 3.0.0 (#191)
  - Bump actions/setup-node from 6.2.0 to 6.3.0 (#177)
@@ -85,7 +87,7 @@
  - Bump hono from 4.12.3 to 4.12.5 (#166) @app/dependabot
  - Bump minimatch from 3.1.2 to 3.1.5 (#161) @app/dependabot
 
-## 0.11.0
+## [0.11.0](https://github.com/FlowFuse/nr-assistant/compare/v0.10.2...v0.11.0) (2026-02-26)
 
  - Bump flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml (#149)
  - Bump flowfuse/github-actions-workflows/.github/workflows/build_node_package.yml (#148)
@@ -98,7 +100,7 @@
  - Bump hono from 4.11.7 to 4.12.0 (#152) @app/dependabot
  - Bump qs from 6.14.1 to 6.14.2 (#146) @app/dependabot
 
-## 0.10.2
+## [0.10.2](https://github.com/FlowFuse/nr-assistant/compare/v0.10.1...v0.10.2) (2026-02-12)
 
  - Bump JS-DevTools/npm-publish from 4.1.4 to 4.1.5 (#136)
  - Bump flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml (#141)
@@ -107,13 +109,13 @@
  - Bump @modelcontextprotocol/sdk from 1.25.3 to 1.26.0 (#138) @app/dependabot
  - Update public catalouge on release (#144) @hardillb
 
-## 0.10.1
+## [0.10.1](https://github.com/FlowFuse/nr-assistant/compare/v0.10.0...v0.10.1) (2026-01-30)
 
  - Bump hono from 4.11.5 to 4.11.7 (#129) @app/dependabot
  - Improve discoverability of supported features (#131) @Steve-Mcl
  - Replace hard coded event mapping with dynamic registrations (#132) @Steve-Mcl
 
-## 0.10.0
+## [0.10.0](https://github.com/FlowFuse/nr-assistant/compare/v0.9.0...v0.10.0) (2026-01-27)
 
  - Bump JS-DevTools/npm-publish from 4.1.3 to 4.1.4 (#110)
  - Bump actions/checkout from 6.0.1 to 6.0.2 (#124)
@@ -122,7 +124,7 @@
  - Bump flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml (#121)
  - Add selection handling: `view:selection-changed` notifier and `get-selection` handler (#125) @cstns
 
-## 0.9.0
+## [0.9.0](https://github.com/FlowFuse/nr-assistant/compare/v0.8.0...v0.9.0) (2026-01-24)
 
  - Update dependencies (#119) @Steve-Mcl
  - Bump actions/setup-node from 6.1.0 to 6.2.0 (#113)
@@ -131,7 +133,7 @@
  - Expose installed packages to flowfuse expert (#114) @cstns
  - ci: Enable SAST (#109) @ppawlowski
 
-## 0.8.0
+## [0.8.0](https://github.com/FlowFuse/nr-assistant/compare/v0.7.0...v0.8.0) (2026-01-14)
 
 - Bump JS-DevTools/npm-publish from 4.1.1 to 4.1.3 (#105)
 - Bump flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml (#96)
@@ -143,7 +145,7 @@
 - Bump flowfuse/github-actions-workflows/.github/workflows/publish_node_package.yml from 0.44.0 to 0.45.0 (#98) @app/dependabot
 - Bump flowfuse/github-actions-workflows/.github/workflows/build_node_package.yml from 0.44.0 to 0.45.0 (#97) @app/dependabot
 
-## 0.7.0
+## [0.7.0](https://github.com/FlowFuse/nr-assistant/compare/v0.6.0...v0.7.0) (2025-12-09)
 
  - Allow the assistant to be installed in standalone Node-RED instances (#89) @knolleary
 
@@ -161,33 +163,33 @@
  - Bump body-parser from 2.2.0 to 2.2.1 (#88) @app/dependabot
  - Bump js-yaml from 4.1.0 to 4.1.1 (#86) @app/dependabot
 
-## 0.6.0
+## [0.6.0](https://github.com/FlowFuse/nr-assistant/compare/v0.5.0...v0.6.0) (2025-09-05)
  - Fix relative script source path (#77) @Steve-Mcl
  - Add inline completions feature (#75) @Steve-Mcl
 
-## 0.5.0
+## [0.5.0](https://github.com/FlowFuse/nr-assistant/compare/v0.4.0...v0.5.0) (2025-08-28)
  - Bump actions/checkout from 4.2.2 to 5.0.0 (#69)
  - Bump flowfuse/github-actions-workflows from 0.40.0 to 0.42.0 (#68)
  - Add tables codelens feature (#72) @Steve-Mcl
 
-## 0.4.0
+## [0.4.0](https://github.com/FlowFuse/nr-assistant/compare/v0.3.0...v0.4.0) (2025-07-30)
  - update package for 0.4.0 release
  - Bump flowfuse/github-actions-workflows from 0.39.0 to 0.40.0 (#60)
  - Update imports (#64) @Steve-Mcl
  - Implement node suggestions (#62) @Steve-Mcl
  - Add copy to clipboard and generate comment node to explain dialog (#61) @Steve-Mcl
 
-## 0.3.0
+## [0.3.0](https://github.com/FlowFuse/nr-assistant/compare/v0.2.1...v0.3.0) (2025-06-27)
  - Change assistant button to menu for exposing new Flows Explainer by @Steve-Mcl in #53
  - Add menu shortcuts for menu items by @Steve-Mcl in #54
  - Show flow explanation in dialog by @Steve-Mcl in #52
  - Add codelens for CSS and DB2 ui-template by @Steve-Mcl in #56
 
-## 0.2.1
+## [0.2.1](https://github.com/FlowFuse/nr-assistant/compare/v0.2.0...v0.2.1) (2025-06-12)
  - Improve README with visuals of what it does by @Steve-Mcl in #49
  - V0.2.1 by @Steve-Mcl in #50
 
-## 0.2.0
+## [0.2.0](https://github.com/FlowFuse/nr-assistant/compare/v0.1.3...v0.2.0) (2025-06-11)
 
  - Bump flowfuse/github-actions-workflows from 0.19.0 to 0.28.0 by @dependabot in #32
  - Bump flowfuse/github-actions-workflows from 0.28.0 to 0.29.0 by @dependabot in #33
@@ -202,17 +204,17 @@
  - Add initial MCP support by @Steve-Mcl in #44
  - V0.2.0 by @Steve-Mcl in #47
 
-## 0.1.3
+## [0.1.3](https://github.com/FlowFuse/nr-assistant/compare/v0.1.2...v0.1.3) (2024-07-17)
 
  - Fix icon on device agent by @Steve-Mcl in #29
  - bump for 0.1.3 by @Steve-Mcl in #30
 
-## 0.1.2
+## [0.1.2](https://github.com/FlowFuse/nr-assistant/compare/v0.1.1...v0.1.2) (2024-07-16)
 
  - Fix height of new icon on NR3.x by @Steve-Mcl in #26
  - bump for 0.1.2 by @Steve-Mcl in #27
 
-## 0.1.1
+## [0.1.1](https://github.com/FlowFuse/nr-assistant/compare/v0.1.0...v0.1.1) (2024-07-16)
 
  - ci: Add build and publish nightly package workflow by @ppawlowski in #7
  - Bump tibdex/github-app-token from 1 to 2 by @dependabot in #11
@@ -223,7 +225,7 @@
  - Add comma to settings.js by @kazuhitoyokoi in #22
  - Improved messaging for error responses by @Steve-Mcl in #24
 
-## 0.1.0
+## 0.1.0 (2024-07-03)
 
  - add automations by @Steve-Mcl in #1
  - Bump JS-DevTools/npm-publish from 2 to 3 by @dependabot in #5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowfuse/nr-assistant",
-    "version": "0.14.0",
+    "version": "0.14.1-5d7a461-202605121018.0",
     "description": "FlowFuse Node-RED Expert plugin",
     "main": "index.js",
     "scripts": {

package/resources/expertAutomations.js

@@ -25,6 +25,12 @@ const GET_NODE_TYPES = 'automation/get-node-types'
 const GET_PALETTE = 'automation/get-palette'
 const LIST_CONFIG_NODES = 'automation/list-config-nodes'
 const OPEN_PALETTE_MANAGER = 'automation/open-palette-manager'
+const MANAGE_GROUPS = 'automation/manage-groups'
+
+const ERROR_CODES = Object.freeze({
+    GROUP_OPERATION_REQUIRED: 'GROUP_OPERATION_REQUIRED',
+    FORBIDDEN_PROPERTY: 'FORBIDDEN_PROPERTY'
+})
 
 /**
  * @typedef {SELECT_NODES
@@ -50,7 +56,8 @@ const OPEN_PALETTE_MANAGER = 'automation/open-palette-manager'
  *   |GET_NODE_TYPES
  *   |GET_PALETTE
  *   |LIST_CONFIG_NODES
- *   |OPEN_PALETTE_MANAGER} ExpertAutomationsActionsEnum
+ *   |OPEN_PALETTE_MANAGER
+ *   |MANAGE_GROUPS} ExpertAutomationsActionsEnum
  */
 
 export class ExpertAutomations extends ExpertActionsInterface {
@@ -187,6 +194,10 @@ export class ExpertAutomations extends ExpertActionsInterface {
                     tabId: {
                         type: 'string',
                         description: 'Optional parameter to only get nodes on a specific workspace. Exclude this parameter to get node from all workspaces.'
+                    },
+                    full: {
+                        type: 'boolean',
+                        description: 'When true, returns the raw node objects instead of condensed summaries.'
                     }
                 }
             }
@@ -268,6 +279,10 @@ export class ExpertAutomations extends ExpertActionsInterface {
                         type: 'array',
                         items: { type: 'string' },
                         description: 'IDs of nodes to remove from the canvas'
+                    },
+                    reconnectWires: {
+                        type: 'boolean',
+                        description: 'If true, reconnects wires around removed nodes (pass-through). Default: false'
                     }
                 },
                 required: ['ids']
@@ -377,6 +392,61 @@ export class ExpertAutomations extends ExpertActionsInterface {
                     }
                 }
             }
+        },
+        [MANAGE_GROUPS]: {
+            params: {
+                type: 'object',
+                properties: {
+                    operations: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                op: {
+                                    type: 'string',
+                                    enum: ['create', 'update', 'manage-members', 'delete'],
+                                    description: 'Operation to perform'
+                                },
+                                id: {
+                                    type: 'string',
+                                    description: 'Group ID (required for update, manage-members, and delete)'
+                                },
+                                nodeIds: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Node IDs: required for create and manage-members'
+                                },
+                                name: {
+                                    type: 'string',
+                                    description: 'Group display name (optional for create and update)'
+                                },
+                                mode: {
+                                    type: 'string',
+                                    enum: ['add', 'remove'],
+                                    description: 'manage-members only — "add" moves nodes into the group, "remove" takes them out'
+                                },
+                                style: {
+                                    type: 'object',
+                                    description: 'Visual style: stroke/border-color, fill, color, stroke-opacity, fill-opacity, label, label-position',
+                                    properties: {
+                                        stroke: { type: 'string' },
+                                        'border-color': { type: 'string' },
+                                        fill: { type: 'string' },
+                                        color: { type: 'string' },
+                                        'stroke-opacity': { type: 'number' },
+                                        'fill-opacity': { type: 'number' },
+                                        label: { type: 'boolean' },
+                                        'label-position': { type: 'string', enum: ['nw', 'n', 'ne', 'sw', 's', 'se'] }
+                                    }
+                                }
+                            },
+                            required: ['op']
+                        },
+                        description: 'Array of group operations to execute sequentially'
+                    }
+                },
+                required: ['operations']
+            }
         }
     })
 
@@ -821,7 +891,7 @@ export class ExpertAutomations extends ExpertActionsInterface {
      * @param {string} id - workspace ID to show
      */
     showWorkspace (id) {
-        if (!this.hasWorkspace(id)) throw new Error(`Workspace ${id} not found`)
+        this._assertWorkspaceExists(id)
         this.RED.workspaces.show(id)
     }
 
@@ -831,9 +901,24 @@ export class ExpertAutomations extends ExpertActionsInterface {
      * @returns {boolean} true if the workspace exists, false otherwise
      */
     hasWorkspace (id) {
-        const ws = this.RED.nodes.workspace(id)
-        if (ws) return true
-        return false
+        return !!this.RED.nodes.workspace(id)
+    }
+
+    /**
+     * Throw if the workspace does not exist.
+     * @param {string} id - workspace ID
+     */
+    _assertWorkspaceExists (id) {
+        if (!this.hasWorkspace(id)) throw new Error(`Workspace ${id} not found`)
+    }
+
+    /**
+     * Throw if the workspace tab is locked. No-op when tabId is falsy (e.g. config nodes).
+     * @param {string|null|undefined} tabId - workspace tab ID
+     */
+    _assertWorkspaceNotLocked (tabId) {
+        if (!tabId) return
+        if (this.RED.workspaces.isLocked(tabId)) throw new Error(`Workspace ${tabId} is locked`)
     }
 
     closeSearch () { this.RED.search.hide() }
@@ -918,9 +1003,8 @@ export class ExpertAutomations extends ExpertActionsInterface {
         // Validate all target tabs exist and are not locked
         const uniqueZs = [...new Set(prepared.map(n => n.z).filter(Boolean))]
         for (const z of uniqueZs) {
-            if (!this.hasWorkspace(z)) throw new Error(`Workspace tab ${z} not found`)
-            const ws = this.RED.nodes.workspace(z)
-            if (ws.locked) throw new Error(`Workspace tab ${z} is locked`)
+            this._assertWorkspaceExists(z)
+            this._assertWorkspaceNotLocked(z)
         }
         // Pre-import: reject if any node ID already exists on the canvas
         if (!generateIds) {
@@ -953,9 +1037,13 @@ export class ExpertAutomations extends ExpertActionsInterface {
 
     /**
      * Remove one or more nodes from the live NR4 canvas by ID.
+     * Delegates to Node-RED's core:delete-selection action to ensure all internal data
+     * structures (including group membership arrays) are properly cleaned up.
      * @param {string[]} ids - node IDs to remove
+     * @param {object} [options]
+     * @param {boolean} [options.reconnectWires=false] - reconnect wires around removed nodes
      */
-    removeNodes (ids) {
+    removeNodes (ids, { reconnectWires = false } = {}) {
         // Resolve all nodes once and check for missing
         const nodes = ids.map(id => {
             const node = this.RED.nodes.node(id)
@@ -964,19 +1052,15 @@ export class ExpertAutomations extends ExpertActionsInterface {
         })
         // Check if any node's workspace is locked
         for (const node of nodes) {
-            if (node.z && this.RED.workspaces.isLocked(node.z)) {
-                throw new Error(`Cannot remove node ${node.id} — workspace ${node.z} is locked`)
-            }
+            this._assertWorkspaceNotLocked(node.z)
         }
-        const allRemovedLinks = []
-        for (const node of nodes) {
-            const removed = this.RED.nodes.remove(node.id)
-            allRemovedLinks.push(...(removed.links || []))
+        this.RED.view.select({ nodes })
+        this._verifySelection(nodes)
+        if (reconnectWires) {
+            this.RED.actions.invoke('core:delete-selection-and-reconnect')
+        } else {
+            this.RED.actions.invoke('core:delete-selection')
         }
-        this.RED.history.push({ t: 'delete', nodes, links: allRemovedLinks, dirty: this.RED.nodes.dirty() })
-        this.RED.nodes.dirty(true)
-        this.RED.view.updateActive()
-        this.RED.view.redraw()
     }
 
     /**
@@ -998,9 +1082,7 @@ export class ExpertAutomations extends ExpertActionsInterface {
             throw new Error('Source and target nodes must be on the same tab')
         }
         // Check workspace is not locked
-        if (sourceNode.z && this.RED.workspaces.isLocked(sourceNode.z)) {
-            throw new Error(`Cannot modify wires — workspace ${sourceNode.z} is locked`)
-        }
+        this._assertWorkspaceNotLocked(sourceNode.z)
         // Validate output port exists on source
         const port = output ?? 0
         if (port >= (sourceNode.outputs || 0)) {
@@ -1069,12 +1151,8 @@ export class ExpertAutomations extends ExpertActionsInterface {
             throw new Error(`Source node ${source} is a link call in dynamic mode and cannot have static links`)
         }
         // Check workspace locks for both nodes
-        if (sourceNode.z && this.RED.workspaces.isLocked(sourceNode.z)) {
-            throw new Error(`Cannot modify links — workspace ${sourceNode.z} is locked`)
-        }
-        if (targetNode.z && targetNode.z !== sourceNode.z && this.RED.workspaces.isLocked(targetNode.z)) {
-            throw new Error(`Cannot modify links — workspace ${targetNode.z} is locked`)
-        }
+        this._assertWorkspaceNotLocked(sourceNode.z)
+        if (targetNode.z !== sourceNode.z) this._assertWorkspaceNotLocked(targetNode.z)
         const isBidirectional = sourceNode.type === 'link out'
         const sourceLinks = sourceNode.links || []
         const targetLinks = targetNode.links || []
@@ -1197,6 +1275,18 @@ export class ExpertAutomations extends ExpertActionsInterface {
             break
 
         case UPDATE_NODE: {
+            if (this.RED.nodes.group(params.id)) {
+                result.error = `Node ${params.id} is a group — group nodes cannot be updated via this action`
+                result.errorCode = ERROR_CODES.GROUP_OPERATION_REQUIRED
+                result.success = false
+                break
+            }
+            if (params.properties && 'g' in params.properties) {
+                result.error = `Node ${params.id}: "g" cannot be set directly — group membership must be managed via a dedicated action`
+                result.errorCode = ERROR_CODES.FORBIDDEN_PROPERTY
+                result.success = false
+                break
+            }
             await this.updateNode(params.id, params.properties, params.patches)
             const updatedNode = this.RED.nodes.node(params.id)
             result.data = this._summarizeNode(updatedNode)
@@ -1216,15 +1306,18 @@ export class ExpertAutomations extends ExpertActionsInterface {
         case GET_FLOW:
             result.flows = this.getFlow()
             if (result.flows && Array.isArray(result.flows) && result.flows.length > 0) {
-                if (params.type) {
+                if (params && params.type) {
                     // filter by type if specified (e.g. "tab", "subflow", or any node type)
                     result.flows = result.flows.filter(f => f.type === params.type)
                 }
-                if (params.tabId) {
+                if (params && params.tabId) {
                     // filter by parent tab ID if specified (for nodes/config nodes)
                     result.flows = result.flows.filter(f => f.z === params.tabId)
                 }
             }
+            if (!params || !params.full) {
+                result.flows = (result.flows || []).map(f => this._summarizeFlowItem(f))
+            }
             result.success = true
             break
 
@@ -1265,6 +1358,20 @@ export class ExpertAutomations extends ExpertActionsInterface {
             break
 
         case ADD_NODES: {
+            const groupNodes = (params.nodes || []).filter(n => n.type === 'group')
+            if (groupNodes.length > 0) {
+                result.error = `Nodes [${groupNodes.map(n => n.id).join(', ')}] are group nodes — group nodes cannot be added via this action`
+                result.errorCode = ERROR_CODES.GROUP_OPERATION_REQUIRED
+                result.success = false
+                break
+            }
+            const gNode = (params.nodes || []).find(n => n.g !== undefined)
+            if (gNode) {
+                result.error = `Node ${gNode.id}: "g" cannot be set directly — group membership must be managed via a dedicated action`
+                result.errorCode = ERROR_CODES.FORBIDDEN_PROPERTY
+                result.success = false
+                break
+            }
             this.addNodes(params.nodes, { generateIds: params.generateIds ?? false })
             const addedNodes = params.nodes.map(n => this.RED.nodes.node(n.id)).filter(Boolean)
             if (this.RED.editor?.validateNode) {
@@ -1276,10 +1383,25 @@ export class ExpertAutomations extends ExpertActionsInterface {
         }
             break
 
-        case REMOVE_NODES:
-            this.removeNodes(params.ids)
+        case REMOVE_NODES: {
+            const groupIds = (params.ids || []).filter(id => !!this.RED.nodes.group(id))
+            if (groupIds.length > 0) {
+                result.error = `IDs [${groupIds.join(', ')}] are group nodes — group nodes cannot be removed via this action`
+                result.errorCode = ERROR_CODES.GROUP_OPERATION_REQUIRED
+                result.success = false
+                break
+            }
+            const groupedNodes = (params.ids || []).map(id => this.RED.nodes.node(id)).filter(n => n && n.g)
+            if (groupedNodes.length > 0) {
+                result.error = `Node ${groupedNodes[0].id}: cannot be removed while it is a member of a group — group membership must be managed via a dedicated action first`
+                result.errorCode = ERROR_CODES.FORBIDDEN_PROPERTY
+                result.success = false
+                break
+            }
+            this.removeNodes(params.ids, { reconnectWires: params.reconnectWires ?? false })
             result.data = { removed: params.ids }
             result.success = true
+        }
             break
 
         case SET_WIRES:
@@ -1362,6 +1484,57 @@ export class ExpertAutomations extends ExpertActionsInterface {
             })
             result.success = true
             break
+        case MANAGE_GROUPS: {
+            const operations = params.operations
+            if (!Array.isArray(operations) || operations.length === 0) {
+                throw new Error('operations array is required and must not be empty')
+            }
+            const results = []
+            for (const entry of operations) {
+                const op = entry.op
+                if (!op) throw new Error('op is required for each manage-groups operation')
+                switch (op) {
+                case 'create': {
+                    const group = this.createGroup(entry.nodeIds, entry.name, { style: entry.style, env: entry.env, id: entry.id })
+                    results.push({ op: 'create', ...this._summarizeGroup(group) })
+                    break
+                }
+                case 'update': {
+                    if (!entry.id) throw new Error('id is required for update')
+                    const group = this.updateGroup(entry.id, {
+                        name: entry.name,
+                        style: entry.style,
+                        env: entry.env
+                    })
+                    results.push({ op: 'update', ...this._summarizeGroup(group) })
+                    break
+                }
+                case 'manage-members': {
+                    if (!entry.id) throw new Error('id is required for manage-members')
+                    if (!entry.nodeIds || entry.nodeIds.length === 0) throw new Error('nodeIds is required for manage-members')
+                    const mode = entry.mode
+                    if (mode !== 'add' && mode !== 'remove') throw new Error('mode must be "add" or "remove"')
+                    const group = this.updateGroup(entry.id, {
+                        nodeIds: entry.nodeIds,
+                        remove: mode === 'remove'
+                    })
+                    results.push({ op: 'manage-members', mode, ...this._summarizeGroup(group) })
+                    break
+                }
+                case 'delete': {
+                    if (!entry.id) throw new Error('id is required for delete')
+                    this.deleteGroup(entry.id)
+                    results.push({ op: 'delete', deleted: entry.id })
+                    break
+                }
+                default:
+                    throw new Error(`Unknown manage-groups op: ${op}`)
+                }
+            }
+            result.data = results
+            result.success = true
+            break
+        }
         default:
             result.handled = false
             result.success = false
@@ -1411,6 +1584,185 @@ export class ExpertAutomations extends ExpertActionsInterface {
         }
     }
 
+    /**
+     * Create a group containing the specified nodes.
+     * Uses Node-RED's core:group-selection action after selecting the target nodes.
+     * @param {string[]} nodeIds - IDs of nodes to group
+     * @param {string} [name] - optional group display name
+     * @param {object} [opts]
+     * @param {object} [opts.style] - visual style overrides
+     * @param {Array}  [opts.env]   - environment variables for nodes inside the group
+     * @param {string} [opts.id]    - explicit group ID; auto-generated if omitted
+     * @returns {object} the created group node
+     */
+    createGroup (nodeIds, name, { style, env, id } = {}) {
+        if (!nodeIds || nodeIds.length === 0) {
+            throw new Error('nodeIds is required and must not be empty')
+        }
+        const nodes = nodeIds.map(id => {
+            const n = this.RED.nodes.node(id)
+            if (!n) throw new Error(`Node ${id} not found`)
+            return n
+        })
+        const tabs = new Set(nodes.map(n => n.z).filter(Boolean))
+        if (tabs.size > 1) {
+            throw new Error('All nodes must be on the same tab to form a group')
+        }
+        const tabId = tabs.size === 1 ? [...tabs][0] : null
+        this._assertWorkspaceNotLocked(tabId)
+
+        // Snapshot existing group IDs so we can identify the newly created one
+        const existingGroupIds = new Set()
+        this.RED.nodes.eachGroup(g => existingGroupIds.add(g.id))
+
+        this.RED.view.select({ nodes })
+        this._verifySelection(nodes)
+        this.RED.actions.invoke('core:group-selection')
+
+        const newGroups = []
+        this.RED.nodes.eachGroup(g => {
+            if (!existingGroupIds.has(g.id)) newGroups.push(g)
+        })
+
+        if (newGroups.length === 0) {
+            throw new Error('Group creation failed: core:group-selection did not create a new group')
+        }
+
+        const newGroup = newGroups[0]
+        const missingIds = nodeIds.filter(nid => !newGroup.nodes?.some(n => (n.id || n) === nid))
+        if (missingIds.length > 0) {
+            throw new Error(`Group created but missing nodes: ${missingIds.join(', ')}`)
+        }
+
+        // Rename to the requested ID if one was provided and differs from the auto-generated one
+        if (id !== undefined && id !== newGroup.id) {
+            if (this.RED.nodes.node(id) || this.RED.nodes.group(id)) {
+                throw new Error(`Group ID ${id} is already in use`)
+            }
+            const oldId = newGroup.id
+            this.RED.nodes.remove(oldId)
+            newGroup.id = id
+            ;(newGroup.nodes || []).forEach(n => {
+                const nodeRef = typeof n === 'object' ? n : this.RED.nodes.node(n)
+                if (nodeRef && nodeRef.g === oldId) nodeRef.g = id
+            })
+            this.RED.nodes.add(newGroup)
+        }
+
+        const changes = {}
+        if (name) {
+            changes.name = newGroup.name
+            newGroup.name = name
+        }
+        if (style) {
+            changes.style = { ...newGroup.style }
+            newGroup.style = Object.assign({}, newGroup.style || {}, style)
+        }
+        if (env !== undefined) {
+            changes.env = newGroup.env
+            newGroup.env = env
+        }
+        if (Object.keys(changes).length > 0) {
+            newGroup.changed = true
+            newGroup.dirty = true
+            this.RED.history.push({ t: 'edit', node: newGroup, changes, changed: false, dirty: this.RED.nodes.dirty() })
+        }
+
+        this.RED.nodes.dirty(true)
+        this.RED.view.redraw()
+        return newGroup
+    }
+
+    /**
+     * Update an existing group: rename, add/remove nodes, change style.
+     * @param {string} id - group ID
+     * @param {object} updates - { name?, addNodeIds?, removeNodeIds?, style? }
+     * @returns {object} the updated group node
+     */
+    updateGroup (id, { name, nodeIds, remove, style, env } = {}) {
+        let group = this.RED.nodes.group(id)
+        if (!group) throw new Error(`Group ${id} not found`)
+        this._assertWorkspaceNotLocked(group.z)
+
+        if (nodeIds && nodeIds.length > 0) {
+            if (remove) {
+                const nodes = nodeIds.map(nodeId => {
+                    const node = this.RED.nodes.node(nodeId)
+                    if (!node) throw new Error(`Node ${nodeId} not found`)
+                    if (node.g !== group.id) throw new Error(`Node ${nodeId} is not in group ${id}`)
+                    return node
+                })
+                this.RED.view.select({ nodes })
+                this._verifySelection(nodes)
+                this.RED.actions.invoke('core:remove-selection-from-group')
+            } else {
+                const existingGroupIds = new Set()
+                this.RED.nodes.eachGroup(g => existingGroupIds.add(g.id))
+
+                const newNodes = nodeIds.map(nodeId => {
+                    const node = this.RED.nodes.node(nodeId)
+                    if (!node) throw new Error(`Node ${nodeId} not found`)
+                    if (node.z !== group.z) throw new Error(`Node ${nodeId} is on tab ${node.z} but group is on tab ${group.z}`)
+                    return node
+                })
+                this.RED.view.select({ nodes: [group, ...newNodes] })
+                this._verifySelection([group, ...newNodes])
+                this.RED.actions.invoke('core:merge-selection-to-group')
+
+                const newGroups = []
+                this.RED.nodes.eachGroup(g => {
+                    if (!existingGroupIds.has(g.id)) newGroups.push(g)
+                })
+                if (newGroups.length === 0) {
+                    throw new Error('Add nodes failed: core:merge-selection-to-group did not create a new group')
+                }
+                group = newGroups[0]
+            }
+        }
+
+        const changes = {}
+
+        if (name !== undefined) {
+            changes.name = group.name
+            group.name = name
+        }
+
+        if (style) {
+            changes.style = { ...group.style }
+            group.style = Object.assign({}, group.style || {}, style)
+        }
+
+        if (env !== undefined) {
+            changes.env = group.env
+            group.env = env
+        }
+
+        if (Object.keys(changes).length > 0) {
+            group.changed = true
+            group.dirty = true
+            this.RED.history.push({ t: 'edit', node: group, changes, changed: false, dirty: this.RED.nodes.dirty() })
+        }
+
+        this.RED.nodes.dirty(true)
+        this.RED.view.redraw()
+        return group
+    }
+
+    /**
+     * Delete a group (ungroup its nodes).
+     * @param {string} id - group ID
+     */
+    deleteGroup (id) {
+        const group = this.RED.nodes.group(id)
+        if (!group) throw new Error(`Group ${id} not found`)
+        this._assertWorkspaceNotLocked(group.z)
+        this.RED.view.select({ nodes: [group] })
+        this._verifySelection([group])
+        this.RED.actions.invoke('core:ungroup-selection')
+        this.RED.nodes.dirty(true)
+        this.RED.view.redraw()
+    }
+
     _summarizeNode (node) {
         if (!node) return null
         const s = { id: node.id }
@@ -1420,7 +1772,65 @@ export class ExpertAutomations extends ExpertActionsInterface {
         if (node.x !== undefined) s.x = node.x
         if (node.y !== undefined) s.y = node.y
         if (node.z !== undefined) s.z = node.z
+        if (node.wires !== undefined) s.wires = node.wires
+        if (node.links !== undefined) s.links = node.links
         if (node.valid !== undefined) s.valid = node.valid
         return s
     }
+
+    /**
+     * Defensive check: verify the view selection contains exactly the expected nodes.
+     * Guards against editor states where RED.view.select() is silently ignored,
+     * which would cause core actions to act on unintended nodes.
+     * @param {object[]} expectedNodes
+     */
+    _verifySelection (expectedNodes) {
+        const selection = this.RED.view.selection()
+        const selectedNodes = selection?.nodes || []
+        const expectedIds = expectedNodes.map(n => n.id)
+        const selectedIds = selectedNodes.map(n => n.id)
+        const expectedSet = new Set(expectedIds)
+        const selectedSet = new Set(selectedIds)
+        if (selectedSet.size !== expectedSet.size || ![...expectedSet].every(id => selectedSet.has(id))) {
+            throw new Error(
+                `Selection mismatch: expected [${expectedIds.join(', ')}] but selection is [${selectedIds.join(', ')}] — editor may be in an unexpected state`
+            )
+        }
+    }
+
+    _summarizeSubflow (subflow) {
+        if (!subflow) return null
+        return {
+            id: subflow.id,
+            type: subflow.type,
+            name: subflow.name,
+            info: subflow.info,
+            inputs: Array.isArray(subflow.in) ? subflow.in.length : 0,
+            outputs: Array.isArray(subflow.out) ? subflow.out.length : 0
+        }
+    }
+
+    _summarizeFlowItem (item) {
+        if (!item) return null
+        if (item.type === 'tab') {
+            const ws = this.RED.nodes.workspace(item.id)
+            return this._summarizeWorkspace(ws)
+        }
+        if (item.type === 'subflow') return this._summarizeSubflow(item)
+        if (item.type === 'group') return this._summarizeGroup(item)
+        return this._summarizeNode(item)
+    }
+
+    _summarizeGroup (group) {
+        if (!group) return null
+        const s = { id: group.id, type: 'group' }
+        if (group.name !== undefined) s.name = group.name
+        if (group.z !== undefined) s.z = group.z
+        if (Array.isArray(group.nodes)) {
+            s.nodes = group.nodes.filter(Boolean).map(n => (typeof n === 'string' ? n : n.id))
+        }
+        if (group.style !== undefined) s.style = group.style
+        if (Array.isArray(group.env) && group.env.length > 0) s.env = group.env
+        return s
+    }
 }