@gmag11/nodered-mcp-server 1.0.1

package/src/tools/export-flow.js

@@ -0,0 +1,161 @@
+/**
+ * MCP tool: export-flow
+ *
+ * Returns a Node-RED-compatible JSON export for a single flow (by flowId),
+ * all flows, or a selected set of nodes (by nodeIds). The returned JSON
+ * string can be passed directly to `import-flow` to duplicate or migrate flows.
+ */
+import { formatSuccess } from './response-utils.js';
+
+
+import { ANN_READONLY } from './constants.js';
+import { GenericObjectSchema } from '../schemas/responses.js';
+/**
+ * Collect the tab node and all child nodes belonging to a given flow.
+ *
+ * @param {object[]} allNodes - All nodes from GET /flows
+ * @param {string} flowId - ID of the tab node to collect
+ * @returns {object[]} Array containing the tab node and all nodes with z === flowId
+ */
+export function collectFlowNodes(allNodes, flowId) {
+  const tab = allNodes.find((n) => n.id === flowId);
+  const children = allNodes.filter((n) => n.z === flowId);
+  return tab ? [tab, ...children] : children;
+}
+
+/**
+ * Collect config nodes (nodes with no `z` property) that are referenced by
+ * any string property of the provided flow nodes.
+ *
+ * @param {object[]} allNodes - All nodes from GET /flows
+ * @param {object[]} flowNodes - The already-collected flow nodes to scan
+ * @returns {object[]} Array of config nodes referenced by the flow nodes
+ */
+export function collectReferencedConfigNodes(allNodes, flowNodes) {
+  // Build a map of config node IDs (nodes with no `z` and not a tab/subflow)
+  const configNodeMap = new Map();
+  for (const node of allNodes) {
+    if (node.z === undefined && node.type !== 'tab' && node.type !== 'subflow') {
+      configNodeMap.set(node.id, node);
+    }
+  }
+
+  if (configNodeMap.size === 0) return [];
+
+  // Collect all string property values from flow nodes (excluding top-level metadata)
+  const metadataKeys = new Set(['id', 'type', 'z', 'x', 'y', 'wires', 'd', 'g', 'l', 'info', 'disabled', 'locked', 'name', 'label']);
+  const referenced = new Set();
+
+  for (const node of flowNodes) {
+    for (const [key, value] of Object.entries(node)) {
+      if (metadataKeys.has(key)) continue;
+      if (typeof value === 'string' && configNodeMap.has(value)) {
+        referenced.add(value);
+      }
+    }
+  }
+
+  return Array.from(referenced).map((id) => configNodeMap.get(id));
+}
+
+/**
+ * Collect nodes from allNodes whose IDs are in the given nodeIds array.
+ *
+ * @param {object[]} allNodes - All nodes from GET /flows
+ * @param {string[]} nodeIds - IDs of nodes to select
+ * @returns {object[]} Array of matching nodes (order follows nodeIds)
+ */
+export function collectSelectedNodes(allNodes, nodeIds) {
+  const nodeMap = new Map(allNodes.map((n) => [n.id, n]));
+  return nodeIds.flatMap((id) => (nodeMap.has(id) ? [nodeMap.get(id)] : []));
+}
+
+/**
+ * Trim wires in a node array so that only targets within allowedIds are kept.
+ * Ports with no remaining targets become `[]`.
+ *
+ * @param {object[]} nodes - Nodes to process (NOT mutated; returns new array)
+ * @param {Set<string>} allowedIds - Set of node IDs that are in the selection
+ * @returns {object[]} New array of nodes with trimmed wires
+ */
+export function trimWires(nodes, allowedIds) {
+  return nodes.map((node) => {
+    if (!Array.isArray(node.wires)) return node;
+    const trimmedWires = node.wires.map((port) =>
+      Array.isArray(port) ? port.filter((targetId) => allowedIds.has(targetId)) : []
+    );
+    return { ...node, wires: trimmedWires };
+  });
+}
+
+/**
+ * Handler for the export-flow MCP tool.
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @param {object} params - Validated input parameters
+ * @param {'flow'|'nodes'} [params.exportMode='flow'] - Export mode
+ * @param {string} [params.flowId] - Tab ID for flow mode
+ * @param {string[]} [params.nodeIds] - Node IDs for nodes mode
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleExportFlowJson(staging, params) {
+  const { exportMode = 'flow', flowId, nodeIds } = params;
+
+  const allNodes = await staging.getFlows();
+
+  let result;
+
+  if (exportMode === 'nodes') {
+    // nodes mode: requires a non-empty nodeIds array
+    if (!nodeIds || nodeIds.length === 0) {
+      throw new Error('exportMode "nodes" requires a non-empty nodeIds array. Provide a list of node IDs to export, or use exportMode: "flow" to export an entire flow tab.');
+    }
+
+    const selectedNodes = collectSelectedNodes(allNodes, nodeIds);
+    const allowedIds = new Set(nodeIds);
+    const trimmedNodes = trimWires(selectedNodes, allowedIds);
+
+    result = {
+      exportMode: 'nodes',
+      nodeCount: trimmedNodes.length,
+      json: JSON.stringify(trimmedNodes),
+    };
+  } else {
+    // flow mode
+    if (flowId) {
+      // Single flow export
+      const tabNode = allNodes.find((n) => n.id === flowId && n.type === 'tab');
+      if (!tabNode) {
+        throw new Error(`Flow '${flowId}' not found. Use get-flows to list available flow tabs.`);
+      }
+
+      const flowNodes = collectFlowNodes(allNodes, flowId);
+      const configNodes = collectReferencedConfigNodes(allNodes, flowNodes);
+      const exportNodes = [...flowNodes, ...configNodes];
+
+      result = {
+        exportMode: 'flow',
+        flowId,
+        label: tabNode.label || '',
+        nodeCount: exportNodes.length,
+        json: JSON.stringify(exportNodes),
+      };
+    } else {
+      // All flows export
+      result = {
+        exportMode: 'flow',
+        nodeCount: allNodes.length,
+        json: JSON.stringify(allNodes),
+      };
+    }
+  }
+
+  return formatSuccess(result);
+}
+
+export const exportFlowDefinition = {
+  name: 'export-flow',
+  annotations: ANN_READONLY,
+  outputSchema: GenericObjectSchema,
+  handler: handleExportFlowJson,
+};

package/src/tools/export-subflow.js

@@ -0,0 +1,78 @@
+/**
+ * MCP tool: export-subflow
+ *
+ * Exports a subflow definition, all its internal nodes, and any referenced
+ * config nodes as a JSON array string compatible with import-flow.
+ */
+
+import { collectReferencedConfigNodes } from './export-flow.js';
+
+import { formatSuccess } from './response-utils.js';
+import { ANN_READONLY } from './constants.js';
+import { GenericObjectSchema } from '../schemas/responses.js';
+/**
+ * Collect the subflow definition, its internal nodes, and referenced config nodes.
+ *
+ * @param {object[]} allNodes - All nodes from GET /flows
+ * @param {string} subflowId - ID of the subflow to export
+ * @returns {{ subflowNodes: object[], name: string, nodeCount: number }}
+ * @throws {Error} If subflowId does not match any type: "subflow" node
+ */
+export function collectSubflowExport(allNodes, subflowId) {
+  // Find the subflow definition
+  const subflow = allNodes.find(
+    (n) => n.type === 'subflow' && n.id === subflowId,
+  );
+
+  if (!subflow) {
+    throw new Error(`Subflow '${subflowId}' not found. Use get-subflows to list available subflow definitions.`);
+  }
+
+  // Collect internal nodes (z === subflowId, with wires property)
+  const internalNodes = allNodes.filter(
+    (n) => n.z === subflowId && ('wires' in n),
+  );
+
+  // Start with definition + internals
+  const subflowNodes = [subflow, ...internalNodes];
+
+  // Collect referenced config nodes
+  const configNodes = collectReferencedConfigNodes(allNodes, subflowNodes);
+
+  const allExported = [...subflowNodes, ...configNodes];
+
+  return {
+    subflowNodes: allExported,
+    name: subflow.name || '',
+    nodeCount: allExported.length,
+  };
+}
+
+/**
+ * Handler for the export-subflow MCP tool.
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @param {object} params
+ * @param {string} params.subflowId
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleExportSubflow(staging, params) {
+  const allNodes = await staging.getFlows();
+
+  const { subflowNodes, name, nodeCount } = collectSubflowExport(allNodes, params.subflowId);
+
+      const data = {
+          subflowId: params.subflowId,
+          name,
+          nodeCount,
+          json: JSON.stringify(subflowNodes),
+        };
+    return formatSuccess(data);
+}
+
+export const exportSubflowDefinition = {
+  name: 'export-subflow',
+  annotations: ANN_READONLY,
+  outputSchema: GenericObjectSchema,
+  handler: handleExportSubflow,
+};

package/src/tools/flow-utils.js

@@ -0,0 +1,376 @@
+/**
+ * Shared utilities for Node-RED flow inspection tools.
+ *
+ * Used by: get-flow-nodes, get-flow-diagram, get-config-nodes
+ */
+
+/**
+ * Node configuration fields that are excluded from responses to avoid
+ * wasting LLM context tokens on large text blobs.
+ *
+ * @type {Set<string>}
+ */
+export const BLOCKLISTED_FIELDS = new Set([
+  'func',       // function node: JavaScript code
+  'template',   // template node: Mustache/HTML template
+  'format',     // various nodes: formatted text content
+  'html',       // html node: HTML content
+  'css',        // ui nodes: CSS styles
+]);
+
+/**
+ * Top-level metadata fields extracted separately; excluded from the config object.
+ *
+ * @type {Set<string>}
+ */
+const METADATA_FIELDS = new Set(['id', 'type', 'z', 'x', 'y', 'wires', 'd', 'name']);
+
+/**
+ * Return a sanitized copy of a node's configuration fields,
+ * excluding blocklisted large-text fields and top-level metadata fields.
+ *
+ * @param {object} node - Raw Node-RED node object
+ * @returns {object} Sanitized config object (may be empty)
+ */
+export function sanitizeNodeConfig(node) {
+  const config = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (!METADATA_FIELDS.has(key) && !BLOCKLISTED_FIELDS.has(key)) {
+      config[key] = value;
+    }
+  }
+  return config;
+}
+
+/**
+ * Extract nodes belonging to a specific flow (tab or subflow).
+ * Throws if the flowId does not match any known tab or subflow.
+ *
+ * Only returns flow-level nodes — config nodes (nodes without a `wires`
+ * property) are excluded even if they share the same `z`. Group nodes
+ * (`type: "group"`) are included since they are visual elements on the canvas.
+ *
+ * @param {object[]} allNodes - All nodes from the /flows response
+ * @param {string} flowId - Target flow ID
+ * @returns {object[]} Flow nodes whose `z` property equals `flowId`
+ * @throws {Error} If no tab or subflow with flowId exists
+ */
+export function getFlowNodes(allNodes, flowId) {
+  const flowExists = allNodes.some(
+    (n) => (n.type === 'tab' || n.type === 'subflow') && n.id === flowId
+  );
+
+  if (!flowExists) {
+    throw new Error(`Flow not found: no tab or subflow with id "${flowId}". Use get-flows to list available flow tabs and subflows.`);
+  }
+
+  return allNodes.filter(
+    (n) => n.z === flowId && (('wires' in n) || n.type === 'group')
+  );
+}
+
+/**
+ * Build a reverse wire index: for each target node ID, the set of source node IDs
+ * that have a wire pointing to it.
+ *
+ * @param {object[]} nodes - Array of Node-RED node objects
+ * @returns {Map<string, Set<string>>} targetId → Set of sourceIds
+ */
+export function buildReverseWireIndex(nodes) {
+  const reverseIndex = new Map();
+
+  for (const node of nodes) {
+    if (!node.wires) continue;
+    for (const portTargets of node.wires) {
+      for (const targetId of portTargets) {
+        if (!reverseIndex.has(targetId)) {
+          reverseIndex.set(targetId, new Set());
+        }
+        reverseIndex.get(targetId).add(node.id);
+      }
+    }
+  }
+
+  return reverseIndex;
+}
+
+/**
+ * Build a forward wire index: for each source node ID, the set of target node IDs
+ * it connects to across all output ports.
+ *
+ * @param {object[]} nodes - Array of Node-RED node objects
+ * @returns {Map<string, Set<string>>} sourceId → Set of targetIds
+ */
+export function buildForwardWireIndex(nodes) {
+  const forwardIndex = new Map();
+
+  for (const node of nodes) {
+    if (!node.wires) continue;
+    const targets = new Set();
+    for (const portTargets of node.wires) {
+      for (const targetId of portTargets) {
+        targets.add(targetId);
+      }
+    }
+    if (targets.size > 0) {
+      forwardIndex.set(node.id, targets);
+    }
+  }
+
+  return forwardIndex;
+}
+
+/**
+ * Get the set of node IDs reachable from `fromNodeId` via BFS in the given direction.
+ *
+ * @param {object[]} nodes - Nodes to search within (already filtered to a flow)
+ * @param {string} fromNodeId - Starting node ID
+ * @param {'downstream'|'upstream'|'both'} direction - Traversal direction
+ * @param {Map<string, Set<string>>} reverseIndex - Reverse wire index (target → sources)
+ * @returns {Set<string>} Set of reachable node IDs (including fromNodeId itself)
+ * @throws {Error} If fromNodeId is not found among the nodes
+ */
+export function getConnectedSubgraph(nodes, fromNodeId, direction, reverseIndex) {
+  const nodeIds = new Set(nodes.map((n) => n.id));
+
+  if (!nodeIds.has(fromNodeId)) {
+    throw new Error(`Node not found in flow: no node with id "${fromNodeId}". Use get-flow-nodes to list nodes in the flow or search-nodes to find a node by name.`);
+  }
+
+  const forwardIndex = buildForwardWireIndex(nodes);
+  const visited = new Set();
+  const queue = [fromNodeId];
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+
+    // Traverse downstream (forward wires)
+    if (direction === 'downstream' || direction === 'both') {
+      const targets = forwardIndex.get(current) || new Set();
+      for (const targetId of targets) {
+        if (!visited.has(targetId) && nodeIds.has(targetId)) {
+          queue.push(targetId);
+        }
+      }
+    }
+
+    // Traverse upstream (reverse wires)
+    if (direction === 'upstream' || direction === 'both') {
+      const sources = reverseIndex.get(current) || new Set();
+      for (const sourceId of sources) {
+        if (!visited.has(sourceId) && nodeIds.has(sourceId)) {
+          queue.push(sourceId);
+        }
+      }
+    }
+  }
+
+  return visited;
+}
+
+/**
+ * Apply the chain of filters to a node list:
+ * 1. Subgraph filter (fromNodeId + direction)
+ * 2. Disabled-only filter
+ * 3. Node type filter
+ *
+ * @param {object[]} nodes - Nodes to filter
+ * @param {object} options
+ * @param {string} [options.fromNodeId] - Filter to connected subgraph from this node ID
+ * @param {'downstream'|'upstream'|'both'} [options.direction='both'] - Traversal direction
+ * @param {boolean} [options.disabledOnly] - Return only disabled nodes
+ * @param {string} [options.nodeType] - Return only nodes of this type
+ * @returns {object[]} Filtered nodes
+ * @throws {Error} If fromNodeId is specified but not found
+ */
+export function applyFilters(nodes, { fromNodeId, direction = 'both', disabledOnly, nodeType } = {}) {
+  let filtered = nodes;
+
+  // 1. Subgraph filter
+  if (fromNodeId) {
+    const reverseIndex = buildReverseWireIndex(nodes);
+    const reachable = getConnectedSubgraph(nodes, fromNodeId, direction, reverseIndex);
+    filtered = filtered.filter((n) => reachable.has(n.id));
+  }
+
+  // 2. Disabled-only filter
+  if (disabledOnly) {
+    filtered = filtered.filter((n) => n.d === true);
+  }
+
+  // 3. Node type filter
+  if (nodeType) {
+    filtered = filtered.filter((n) => n.type === nodeType);
+  }
+
+  return filtered;
+}
+
+/**
+ * Paginate an array of items with offset + limit.
+ *
+ * @template T
+ * @param {T[]} items - Full array of items (post-filter)
+ * @param {number} offset - Zero-based start index (default 0)
+ * @param {number} limit - Maximum number of items to return (default 50)
+ * @returns {{ items: T[], totalCount: number, offset: number, limit: number, hasMore: boolean }}
+ */
+export function paginate(items, offset = 0, limit = 50) {
+  const totalCount = items.length;
+  const sliced = items.slice(offset, offset + limit);
+  return {
+    items: sliced,
+    totalCount,
+    offset,
+    limit,
+    hasMore: offset + limit < totalCount,
+  };
+}
+
+/**
+ * Compute a bounding rectangle that encloses a set of nodes.
+ * Returns `{ x, y, w, h }` with optional padding on all sides.
+ *
+ * If the nodes array is empty, returns a zero-sized box at origin.
+ *
+ * @param {object[]} nodes - Array of nodes with `x` and `y` properties
+ * @param {number} [padding=20] - Padding to add on all sides
+ * @returns {{ x: number, y: number, w: number, h: number }}
+ */
+export function computeBoundingBox(nodes, padding = 20) {
+  if (nodes.length === 0) {
+    return { x: 0, y: 0, w: 0, h: 0 };
+  }
+
+  const xs = nodes.map((n) => n.x ?? 0);
+  const ys = nodes.map((n) => n.y ?? 0);
+
+  const minX = Math.min(...xs);
+  const minY = Math.min(...ys);
+  const maxX = Math.max(...xs);
+  const maxY = Math.max(...ys);
+
+  return {
+    x: minX - padding,
+    y: minY - padding,
+    w: maxX - minX + 2 * padding,
+    h: maxY - minY + 2 * padding,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Credential normalization (shared by update-node and create-node)
+// ---------------------------------------------------------------------------
+
+/**
+ * Known credential field names commonly used across Node-RED node types.
+ * When these appear at the top level of properties, they should be nested
+ * under `credentials` to match Node-RED's credential storage model.
+ *
+ * Node-RED stores sensitive fields (passwords, API keys, certificates) in a
+ * separate `credentials` object. Putting them at the top level of the node
+ * would cause Node-RED to treat them as regular (non-credential) properties.
+ *
+ * @type {Set<string>}
+ */
+export const CREDENTIAL_FIELD_NAMES = new Set([
+  'username', 'password', 'passphrase', 'key', 'privateKey',
+  'cert', 'ca', 'clientKey', 'clientCert', 'token', 'secret',
+  'accessKey', 'secretKey', 'apiKey', 'bearerToken', 'psk',
+  'pass', 'user', 'passkey', 'sharedKey', 'hmacKey',
+]);
+
+/**
+ * Normalize properties by moving credential fields into a `credentials`
+ * sub-object, deep-merging with existing credentials to preserve
+ * unspecified fields.
+ *
+ * Detection strategy (in priority order):
+ * 1. If `credentialKeys` is provided (from the `/credentials/:type/:id` API),
+ *    it is used as the authoritative list of credential field names.
+ * 2. If the caller already sent a `credentials` property, deep-merge it
+ *    with the node's existing `credentials` (preserving unspecified fields).
+ * 3. If the node has an existing `credentials` object (even if masked),
+ *    use its keys to identify which incoming properties are credentials.
+ * 4. Fallback: match incoming properties against the well-known set of
+ *    credential field names (CREDENTIAL_FIELD_NAMES).
+ *
+ * When `node` is null/undefined (used by create-node where no existing
+ * node exists), only strategies 1, 2, and 4 apply.
+ *
+ * @param {object} properties - Incoming properties from the caller
+ * @param {object|null} [node=null] - The existing node object (from GET /flows), or null for new nodes
+ * @param {string[]|null} [credentialKeys=null] - Authoritative list of credential field names from the Node-RED API, or null to auto-detect
+ * @returns {object} Normalized properties with credentials nested correctly
+ */
+export function normalizeCredentials(properties, node = null, credentialKeys = null) {
+  const props = { ...properties };
+
+  // Case 1: caller already provided a `credentials` object → deep-merge
+  if (props.credentials && typeof props.credentials === 'object' && !Array.isArray(props.credentials)) {
+    const existingCreds = (node && node.credentials && typeof node.credentials === 'object' && !Array.isArray(node.credentials))
+      ? { ...node.credentials }
+      : {};
+    props.credentials = { ...existingCreds, ...props.credentials };
+    return props;
+  }
+
+  // Case 2: credential keys provided by API → use as authoritative list.
+  // null means "API not consulted", [] means "API confirmed no credentials".
+  if (credentialKeys !== null) {
+    // Empty array = node type has no credentials defined → don't move anything
+    if (credentialKeys.length === 0) {
+      return { ...props };
+    }
+
+    const credProps = {};
+    const nonCredProps = {};
+
+    for (const [key, value] of Object.entries(props)) {
+      if (key === 'credentials') continue;
+      if (credentialKeys.includes(key)) {
+        credProps[key] = value;
+      } else {
+        nonCredProps[key] = value;
+      }
+    }
+
+    if (Object.keys(credProps).length > 0) {
+      const existingCreds = (node && node.credentials && typeof node.credentials === 'object' && !Array.isArray(node.credentials))
+        ? { ...node.credentials }
+        : {};
+      nonCredProps.credentials = { ...existingCreds, ...credProps };
+    }
+
+    return nonCredProps;
+  }
+
+  // Case 3+4: auto-detect from node.credentials keys or fallback heuristic
+  const existingCredKeys = (node && node.credentials && typeof node.credentials === 'object' && !Array.isArray(node.credentials))
+    ? Object.keys(node.credentials)
+    : [];
+
+  const credProps = {};
+  const nonCredProps = {};
+
+  for (const [key, value] of Object.entries(props)) {
+    if (key === 'credentials') continue;
+
+    if (existingCredKeys.includes(key) || CREDENTIAL_FIELD_NAMES.has(key)) {
+      credProps[key] = value;
+    } else {
+      nonCredProps[key] = value;
+    }
+  }
+
+  if (Object.keys(credProps).length > 0) {
+    const existingCreds = (node && node.credentials && typeof node.credentials === 'object' && !Array.isArray(node.credentials))
+      ? { ...node.credentials }
+      : {};
+    nonCredProps.credentials = { ...existingCreds, ...credProps };
+  }
+
+  return nonCredProps;
+}

package/src/tools/get-config-nodes.js

@@ -0,0 +1,86 @@
+/**
+ * MCP tool: get-config-nodes
+ *
+ * Returns a paginated list of global configuration nodes from the connected
+ * Node-RED instance.  Configuration nodes are shared resources (e.g. MQTT
+ * brokers, TLS configs) used by flow nodes but not wired on the canvas.
+ */
+
+import {
+  sanitizeNodeConfig,
+  paginate,
+} from './flow-utils.js';
+import { formatSuccess } from './response-utils.js';
+
+import { ANN_READONLY } from './constants.js';
+import { ConfigNodesResponseSchema } from '../schemas/responses.js';
+/**
+ * Transform a raw /flows response into a paginated list of global config nodes.
+ *
+ * Config nodes are those that:
+ * - Have no `wires` property (unlike flow nodes, config nodes are not wired)
+ * - Are not of type `tab` or `subflow`
+ *
+ * Note: config nodes *may* have a `z` property when defined within a flow tab.
+ *
+ * @param {object} rawResponse - Response from GET /flows (v2 format: { rev, flows })
+ * @param {object} [options]
+ * @param {string} [options.nodeType] - Return only config nodes of this type
+ * @param {number} [options.offset=0] - Pagination offset
+ * @param {number} [options.limit=50] - Pagination limit
+ * @returns {{ nodes: object[], totalCount: number, offset: number, limit: number, hasMore: boolean }}
+ */
+export function transformConfigNodes(rawResponse, options = {}) {
+  const { nodeType, offset = 0, limit = 50 } = options;
+  const allNodes = rawResponse.flows || [];
+
+  // Config nodes: no wires property (not placed on canvas), and not tab or subflow
+  let configNodes = allNodes.filter(
+    (n) => !('wires' in n) && n.type !== 'tab' && n.type !== 'subflow'
+  );
+
+  // Optional type filter
+  if (nodeType) {
+    configNodes = configNodes.filter((n) => n.type === nodeType);
+  }
+
+  // Paginate
+  const page = paginate(configNodes, offset, limit);
+
+  // Shape each node
+  const nodes = page.items.map((node) => ({
+    id: node.id,
+    type: node.type,
+    name: node.name || '',
+    config: sanitizeNodeConfig(node),
+  }));
+
+  return {
+    nodes,
+    totalCount: page.totalCount,
+    offset: page.offset,
+    limit: page.limit,
+    hasMore: page.hasMore,
+  };
+}
+
+/**
+ * Handler for the get-config-nodes MCP tool.
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @param {object} params - Validated input parameters
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleGetConfigNodes(staging, params) {
+  const flows = await staging.getFlows();
+  const result = transformConfigNodes({ flows }, params);
+
+  return formatSuccess(result);
+}
+
+export const getConfigNodesDefinition = {
+  name: 'get-config-nodes',
+  annotations: ANN_READONLY,
+  outputSchema: ConfigNodesResponseSchema,
+  handler: handleGetConfigNodes,
+};