@gmag11/nodered-mcp-server 1.0.1

package/src/tools/get-subflow-detail.js

@@ -0,0 +1,110 @@
+/**
+ * MCP tool: get-subflow-detail
+ *
+ * Returns the full definition of a single subflow including:
+ * - The subflow definition node
+ * - All internal nodes (with sanitized configs)
+ * - All instances placed in flow tabs
+ * - A Mermaid diagram of the internal flow
+ */
+
+import { getFlowNodes, sanitizeNodeConfig } from './flow-utils.js';
+import { buildIR } from '../renderer/ir-builder.js';
+import { buildMermaid } from '../renderer/mermaid-builder.js';
+import { formatSuccess } from './response-utils.js';
+
+import { ANN_READONLY } from './constants.js';
+import { SubflowDetailResponseSchema } from '../schemas/responses.js';
+/**
+ * Transform the raw /flows response into a detailed subflow view.
+ *
+ * @param {object} rawResponse - Response from GET /flows (v2 format: { rev, flows })
+ * @param {string} subflowId - ID of the subflow to inspect
+ * @returns {{
+ *   definition: object,
+ *   internalNodes: object[],
+ *   instances: object[],
+ *   diagram: string
+ * }}
+ * @throws {Error} If subflowId does not match any type: "subflow" node
+ */
+export function transformSubflowDetail(rawResponse, subflowId) {
+  const allNodes = rawResponse.flows || [];
+
+  // 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.`);
+  }
+
+  // Get internal nodes using the shared flow-utils (validates consistency)
+  let internalNodes;
+  try {
+    internalNodes = getFlowNodes(allNodes, subflowId);
+  } catch {
+    internalNodes = [];
+  }
+
+  // Get all instances (nodes of type "subflow:<subflowId>")
+  const instanceType = `subflow:${subflowId}`;
+  const instances = allNodes.filter((n) => n.type === instanceType);
+
+  // Generate Mermaid diagram from internal nodes (via shared renderer)
+  const ir = buildIR(internalNodes);
+  const diagram = buildMermaid(ir);
+
+  // Sanitize internal nodes: metadata + config (like get-flow-nodes does)
+  const sanitizedInternals = internalNodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    name: node.name || '',
+    disabled: node.d === true,
+    x: node.x,
+    y: node.y,
+    wires: node.wires || [],
+    config: sanitizeNodeConfig(node),
+  }));
+
+  // Simplify instances to key fields
+  const simplifiedInstances = instances.map((node) => ({
+    id: node.id,
+    name: node.name || '',
+    flowId: node.z || '',
+    x: node.x,
+    y: node.y,
+    wires: node.wires || [],
+    env: node.env || [],
+  }));
+
+  return {
+    definition: subflow,
+    internalNodes: sanitizedInternals,
+    instances: simplifiedInstances,
+    diagram,
+  };
+}
+
+/**
+ * Handler for the get-subflow-detail 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 handleGetSubflowDetail(staging, params) {
+  const flows = await staging.getFlows();
+  const result = transformSubflowDetail({ flows }, params.subflowId);
+
+  return formatSuccess(result);
+}
+
+export const getSubflowDetailDefinition = {
+  name: 'get-subflow-detail',
+  annotations: ANN_READONLY,
+  outputSchema: SubflowDetailResponseSchema,
+  handler: handleGetSubflowDetail,
+};

package/src/tools/get-subflows.js

@@ -0,0 +1,105 @@
+/**
+ * MCP tool: get-subflows
+ *
+ * Returns a summarized list of subflow definitions from the connected
+ * Node-RED instance, with enriched metadata for LLM consumption.
+ */
+import { formatSuccess } from './response-utils.js';
+
+
+import { ANN_READONLY } from './constants.js';
+import { SubflowSummarySchema } from '../schemas/responses.js';
+import { z } from 'zod';
+/**
+ * Transform the raw Node-RED /flows response into an LLM-friendly
+ * summary of subflow definitions only.
+ *
+ * @param {object} rawResponse - Response from GET /flows (v2 format: { rev, flows })
+ * @returns {Array<{
+ *   id: string,
+ *   name: string,
+ *   info: string,
+ *   inputCount: number,
+ *   outputCount: number,
+ *   internalNodeCount: number,
+ *   internalNodeTypes: string[],
+ *   instanceCount: number,
+ *   instances: Array<{ id: string, name: string, flowId: string }>
+ * }>}
+ */
+export function transformSubflows(rawResponse) {
+  const allNodes = rawResponse.flows || [];
+
+  // Identify subflow definitions only
+  const subflows = allNodes.filter(
+    (node) => node.type === 'subflow',
+  );
+
+  if (subflows.length === 0) return [];
+
+  // Build lookup for instance nodes (type: "subflow:<id>")
+  const subflowTypeSet = new Set(subflows.map((sf) => sf.id));
+  const instancesBySubflow = new Map();
+  const childrenBySubflow = new Map();
+
+  for (const sf of subflows) {
+    instancesBySubflow.set(sf.id, []);
+    childrenBySubflow.set(sf.id, []);
+  }
+
+  for (const node of allNodes) {
+    // Collect internal nodes (z === subflowId)
+    if (node.z && childrenBySubflow.has(node.z)) {
+      childrenBySubflow.get(node.z).push(node);
+    }
+    // Collect instances (type === "subflow:<id>")
+    if (node.type && node.type.startsWith('subflow:')) {
+      const subflowId = node.type.slice('subflow:'.length);
+      if (instancesBySubflow.has(subflowId)) {
+        instancesBySubflow.get(subflowId).push(node);
+      }
+    }
+  }
+
+  return subflows.map((sf) => {
+    const children = childrenBySubflow.get(sf.id) || [];
+    const instances = instancesBySubflow.get(sf.id) || [];
+    const uniqueTypes = [...new Set(children.map((n) => n.type))];
+
+    return {
+      id: sf.id,
+      name: sf.name || '',
+      info: sf.info || '',
+      inputCount: Array.isArray(sf.in) ? sf.in.length : 0,
+      outputCount: Array.isArray(sf.out) ? sf.out.length : 0,
+      internalNodeCount: children.length,
+      internalNodeTypes: uniqueTypes,
+      instanceCount: instances.length,
+      instances: instances.map((i) => ({
+        id: i.id,
+        name: i.name || '',
+        flowId: i.z || '',
+      })),
+    };
+  });
+}
+
+/**
+ * Handler for the get-subflows MCP tool.
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleGetSubflows(staging) {
+  const flows = await staging.getFlows();
+  const subflows = transformSubflows({ flows });
+
+  return formatSuccess({ subflows });
+}
+
+export const getSubflowsDefinition = {
+  name: 'get-subflows',
+  annotations: ANN_READONLY,
+  outputSchema: z.object({ subflows: z.array(SubflowSummarySchema) }),
+  handler: handleGetSubflows,
+};

package/src/tools/import-flow.js

@@ -0,0 +1,310 @@
+/**
+ * MCP tool: import-flow
+ *
+ * Imports a Node-RED flow JSON (array or { nodes: [...] } object) into the
+ * running Node-RED instance. Supports two conflict strategies (regenerate /
+ * overwrite) and an optional targetFlowId to inject nodes into an existing tab.
+ *
+ * All flows are redeployed on import (PUT /flows full deploy).
+ */
+
+import { randomUUID } from 'crypto';
+
+import { formatSuccess } from './response-utils.js';
+import { ANN_MUTATION } from './constants.js';
+import { ImportFlowResponseSchema } from '../schemas/responses.js';
+/**
+ * Parse and normalize a flowJson string to a flat node array.
+ *
+ * Accepts:
+ *   - A JSON array string: `[ {...}, ... ]`
+ *   - A JSON object string with a `nodes` property: `{ "nodes": [ {...}, ... ] }`
+ *
+ * @param {string} input - Raw JSON string from the caller
+ * @returns {object[]} Flat array of Node-RED node objects
+ * @throws {Error} On invalid JSON, wrong shape, or empty array
+ */
+export function normalizeFlowJson(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    throw new Error('Invalid flowJson: not valid JSON. Provide a JSON string representing a Node-RED flow array or an object with a "nodes" array.');
+  }
+
+  let nodes;
+  if (Array.isArray(parsed)) {
+    nodes = parsed;
+  } else if (parsed && typeof parsed === 'object' && Array.isArray(parsed.nodes)) {
+    nodes = parsed.nodes;
+  } else {
+    throw new Error('Invalid flowJson: expected a JSON array or an object with a "nodes" array. Example: [{"id":"...","type":"debug"}] or {"nodes":[...]}');
+  }
+
+  if (nodes.length === 0) {
+    throw new Error('flowJson is empty — nothing to import. Provide at least one node in the JSON array.');
+  }
+
+  return nodes;
+}
+
+/**
+ * Remap all `id` and `z` fields in a node array to fresh UUIDs, preserving
+ * all internal references (wire targets, `z` cross-references).
+ *
+ * @param {object[]} nodes - Node array to remap (not mutated)
+ * @returns {object[]} New array with remapped IDs
+ */
+export function regenerateIds(nodes) {
+  // Build old-id → new-id map
+  const idMap = new Map();
+  for (const node of nodes) {
+    if (node.id) {
+      idMap.set(node.id, randomUUID());
+    }
+  }
+
+  return nodes.map((node) => {
+    const remapped = { ...node };
+
+    // Remap own id
+    if (node.id && idMap.has(node.id)) {
+      remapped.id = idMap.get(node.id);
+    }
+
+    // Remap z (parent flow reference)
+    if (node.z && idMap.has(node.z)) {
+      remapped.z = idMap.get(node.z);
+    }
+
+    // Remap wire targets
+    if (Array.isArray(node.wires)) {
+      remapped.wires = node.wires.map((port) =>
+        Array.isArray(port)
+          ? port.map((targetId) => idMap.get(targetId) ?? targetId)
+          : port
+      );
+    }
+
+    return remapped;
+  });
+}
+
+/**
+ * Merge imported nodes into the existing flows array using the given strategy.
+ *
+ * Strategies:
+ *   - `regenerate`: imported nodes have already had IDs regenerated, so there
+ *     are no collisions. Just append.
+ *   - `overwrite`: replace any existing node whose ID matches an imported node,
+ *     then append remaining new nodes.
+ *
+ * @param {object[]} existing - Current flows array from GET /flows
+ * @param {object[]} imported - Imported nodes (already strategy-processed)
+ * @param {'regenerate'|'overwrite'} strategy
+ * @returns {{ updatedFlows: object[], conflicts: number }}
+ */
+export function mergeFlows(existing, imported, strategy) {
+  if (strategy === 'regenerate') {
+    // IDs are all fresh — no possible conflicts, just append
+    return { updatedFlows: [...existing, ...imported], conflicts: 0 };
+  }
+
+  if (strategy === 'overwrite') {
+    const importedById = new Map(imported.map((n) => [n.id, n]));
+    let conflicts = 0;
+
+    // Replace existing nodes that are being overwritten
+    const kept = existing.map((node) => {
+      if (importedById.has(node.id)) {
+        conflicts++;
+        return importedById.get(node.id);
+      }
+      return node;
+    });
+
+    // Append imported nodes that were not replacements (new IDs)
+    const existingIds = new Set(existing.map((n) => n.id));
+    const brandNew = imported.filter((n) => !existingIds.has(n.id));
+
+    return { updatedFlows: [...kept, ...brandNew], conflicts };
+  }
+
+  throw new Error(`Unknown conflictStrategy '${strategy}'. Use "regenerate" (new IDs, no collisions) or "overwrite" (replace existing nodes with matching IDs).`);
+}
+
+/**
+ * Discard tab nodes from the imported array and remap all remaining nodes'
+ * `z` field to the given targetFlowId.
+ *
+ * @param {object[]} nodes - Imported node array
+ * @param {string} targetFlowId - ID of the existing flow tab to inject into
+ * @returns {object[]} Non-tab nodes with `z` set to targetFlowId
+ */
+export function applyTargetFlow(nodes, targetFlowId) {
+  return nodes
+    .filter((n) => n.type !== 'tab' && n.type !== 'subflow')
+    .map((n) => ({ ...n, z: targetFlowId }));
+}
+
+/**
+ * Reposition imported nodes into a free area of the target flow, avoiding
+ * overlap with existing nodes.
+ *
+ * Strategy: place the imported nodes to the right of the existing nodes,
+ * preserving the internal relative layout of the imported group.
+ *
+ * @param {object[]} existingNodes - Nodes already in the target flow
+ * @param {object[]} importedNodes - Nodes being imported (already remapped)
+ * @returns {object[]} Imported nodes with adjusted x, y positions
+ */
+export function repositionNodes(existingNodes, importedNodes) {
+  // Filter to only regular nodes (not tabs/subflows/config nodes)
+  const regularExisting = existingNodes.filter(
+    (n) => n.x !== undefined && n.y !== undefined,
+  );
+
+  // Find rightmost position of existing nodes
+  let existingMaxX = 0;
+  let existingMinY = Infinity;
+  for (const node of regularExisting) {
+    if (node.x > existingMaxX) existingMaxX = node.x;
+    if (node.y < existingMinY) existingMinY = node.y;
+  }
+  // Default if no existing nodes with positions
+  if (!isFinite(existingMinY)) existingMinY = 80;
+
+  // Find leftmost position of imported nodes (for relative offset)
+  let importedMinX = Infinity;
+  let importedMinY = Infinity;
+  for (const node of importedNodes) {
+    if (node.x !== undefined && node.x < importedMinX) importedMinX = node.x;
+    if (node.y !== undefined && node.y < importedMinY) importedMinY = node.y;
+  }
+  // Default if imported nodes have no positions
+  if (!isFinite(importedMinX)) importedMinX = 120;
+  if (!isFinite(importedMinY)) importedMinY = 80;
+
+  // Gap between existing rightmost edge and imported leftmost edge
+  const HORIZONTAL_GAP = 200;
+
+  const offsetX = existingMaxX - importedMinX + HORIZONTAL_GAP;
+  const offsetY = existingMinY - importedMinY;
+
+  return importedNodes.map((node) => ({
+    ...node,
+    x: (node.x ?? importedMinX) + offsetX,
+    y: (node.y ?? importedMinY) + offsetY,
+  }));
+}
+
+/**
+ * Build the import summary object.
+ *
+ * @param {object[]} importedNodes - The nodes that were merged into the instance
+ * @param {number} conflicts - Number of ID collisions resolved
+ * @param {string} strategy - The conflict strategy applied
+ * @param {string|null} targetFlowId - The targetFlowId if used, else null
+ * @returns {{ imported: { flows: number, nodes: number, configNodes: number }, conflicts: number, strategy: string, targetFlowId: string|null }}
+ */
+export function summarizeImport(importedNodes, conflicts, strategy, targetFlowId) {
+  let flows = 0;
+  let nodes = 0;
+  let configNodes = 0;
+
+  for (const node of importedNodes) {
+    if (node.type === 'tab' || node.type === 'subflow') {
+      flows++;
+    } else if (node.z === undefined || node.z === null || node.z === '') {
+      configNodes++;
+    } else {
+      nodes++;
+    }
+  }
+
+  return {
+    imported: { flows, nodes, configNodes },
+    conflicts,
+    strategy,
+    targetFlowId: targetFlowId ?? null,
+  };
+}
+
+/**
+ * Handler for the import-flow MCP tool.
+ *
+ * Orchestration:
+ *  1. Validate targetFlowId (if provided) — must exist and not be locked
+ *  2. Fetch existing flows
+ *  3. Normalize imported JSON
+ *  4. Apply targetFlow remapping or standard conflict strategy
+ *  5. PUT /flows with merged result
+ *  6. Return summary
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @param {object} params
+ * @param {string} params.flowJson - Raw Node-RED flow JSON string
+ * @param {'regenerate'|'overwrite'} [params.conflictStrategy='regenerate']
+ * @param {string} [params.targetFlowId]
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleImportFlow(staging, client, params) {
+  const { flowJson, conflictStrategy = 'regenerate', targetFlowId } = params;
+
+  // Step 1: validate conflictStrategy early (before any network calls)
+  if (conflictStrategy !== 'regenerate' && conflictStrategy !== 'overwrite') {
+    throw new Error(`Unknown conflictStrategy '${conflictStrategy}'. Use "regenerate" or "overwrite"`);
+  }
+
+  // Step 2: Normalize the incoming JSON (pure, no network)
+  const importedNodes = normalizeFlowJson(flowJson);
+
+  // Step 3: Compute the nodes to merge (deterministic, no network dependency)
+  let nodesToMerge;
+  if (targetFlowId) {
+    const remapped = applyTargetFlow(importedNodes, targetFlowId);
+    nodesToMerge = conflictStrategy === 'regenerate' ? regenerateIds(remapped) : remapped;
+  } else if (conflictStrategy === 'regenerate') {
+    nodesToMerge = regenerateIds(importedNodes);
+  } else {
+    nodesToMerge = importedNodes;
+  }
+
+  // Step 4: Merge and stage locally
+  const mergeStrategy = (targetFlowId && conflictStrategy !== 'overwrite') ? 'regenerate' : conflictStrategy;
+
+  const result = await staging.applyMutation((rawResponse) => {
+    const existing = rawResponse.flows || [];
+
+    // Validate targetFlowId if provided
+    if (targetFlowId) {
+      const targetTab = existing.find(
+        (n) => n.id === targetFlowId && (n.type === 'tab' || n.type === 'subflow'),
+      );
+      if (!targetTab) {
+        throw new Error(`Target flow '${targetFlowId}' not found. Use get-flows to list available flow tabs.`);
+      }
+      if (targetTab.locked) {
+        throw new Error(`Target flow '${targetFlowId}' is locked. This flow is locked (read-only). Use get-flow-nodes to inspect its nodes without modifying them.`);
+      }
+
+      // Reposition imported nodes to avoid overlap with existing nodes in the target tab
+      const existingInTarget = existing.filter((n) => n.z === targetFlowId);
+      nodesToMerge = repositionNodes(existingInTarget, nodesToMerge);
+    }
+
+    return mergeFlows(existing, nodesToMerge, mergeStrategy);
+  });
+
+  const summary = summarizeImport(nodesToMerge, result.conflicts, conflictStrategy, targetFlowId ?? null);
+
+      const data = { ...summary, staging: staging.getStagingSummary() };
+    return formatSuccess(data);
+}
+
+export const importFlowDefinition = {
+  name: 'import-flow',
+  annotations: ANN_MUTATION,
+  outputSchema: ImportFlowResponseSchema,
+  handler: handleImportFlow,
+};

package/src/tools/inject-message.js

@@ -0,0 +1,117 @@
+import { ANN_INJECT } from './constants.js';
+import { InjectMessageResponseSchema } from '../schemas/responses.js';
+/**
+ * MCP tool: inject-message
+ *
+ * Fires an inject node by node ID or by name (optionally scoped to a flow).
+ * Uses the Node-RED Admin API POST /inject/:nodeId endpoint.
+ */
+
+/**
+ * Resolve an inject node from all flows by nodeId or by name (+ optional flowId).
+ *
+ * @param {object[]} allNodes - All nodes from the GET /flows response
+ * @param {object} options
+ * @param {string} [options.nodeId] - The node UUID to inject
+ * @param {string} [options.name] - The node name to search for
+ * @param {string} [options.flowId] - Flow ID to scope the name search
+ * @returns {{ nodeId: string, name?: string }} The resolved node
+ * @throws {Error} If not found, ambiguous, or no identifier provided
+ */
+export function resolveInjectNode(allNodes, { nodeId, name, flowId } = {}) {
+  // Must have at least one identifier
+  if (!nodeId && !name) {
+    throw new Error('Provide either nodeId or name. Use nodeId to target a specific inject node by UUID, or name with optional flowId to search by label.');
+  }
+
+  // If nodeId is given, find directly
+  if (nodeId) {
+    const node = allNodes.find((n) => n.id === nodeId);
+    if (!node) {
+      throw new Error(`Inject node not found: no node with id "${nodeId}". Use search-nodes with type: "inject" to find available inject nodes.`);
+    }
+    return { nodeId: node.id, name: node.name };
+  }
+
+  // Resolve by name (+ optional flowId)
+  let candidates = allNodes.filter(
+    (n) => n.name === name && n.type === 'inject',
+  );
+
+  if (flowId) {
+    candidates = candidates.filter((n) => n.z === flowId);
+  }
+
+  if (candidates.length === 0) {
+    const scope = flowId ? ` in flow "${flowId}"` : '';
+    throw new Error(
+      `Inject node not found: no inject node named "${name}"${scope}. Use search-nodes with type: "inject" to find available inject nodes by name.`,
+    );
+  }
+
+  if (candidates.length > 1) {
+    const ids = candidates.map((n) => `"${n.id}"`).join(', ');
+    throw new Error(
+      `Multiple inject nodes named "${name}" found (${ids}). Use nodeId to disambiguate.`,
+    );
+  }
+
+  return { nodeId: candidates[0].id, name: candidates[0].name };
+}
+
+/**
+ * Handler for the inject-message MCP tool.
+ *
+ * @param {import('../staging-store.js').StagingStore} staging
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @returns {(params: { nodeId?: string, name?: string, flowId?: string }) => Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export function handleInjectMessage(staging, client) {
+  return async (params) => {
+    const { nodeId, name, flowId } = params;
+
+    // Pre-deploy guard: refuse to inject if there are undeployed changes
+    if (staging.hasPendingChanges()) {
+      const summary = staging.getStagingSummary();
+      throw new Error(
+        `Cannot inject: there are ${summary.pendingChanges} undeployed change(s). ` +
+        `Call \`deploy\` first to push your pending changes to Node-RED. ` +
+        `Dirty nodes: ${summary.dirtyNodeIds.join(', ') || 'none'}. ` +
+        `Dirty flows: ${summary.dirtyFlowIds.join(', ') || 'none'}.`,
+      );
+    }
+
+    // Fetch all flows from staging to resolve the inject node
+    const allNodes = await staging.getFlows();
+
+    // Resolve the target inject node
+    const resolved = resolveInjectNode(allNodes, { nodeId, name, flowId });
+
+    // Call POST /inject/:nodeId
+    const result = await client.post(`/inject/${resolved.nodeId}`);
+
+    const responseData = {
+      success: true,
+      nodeId: resolved.nodeId,
+      name: resolved.name,
+      message: typeof result === 'string' ? result : 'Injected',
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(responseData, null, 2),
+        },
+      ],
+      structuredContent: responseData,
+    };
+  };
+}
+
+export const injectMessageDefinition = {
+  name: 'inject-message',
+  annotations: ANN_INJECT,
+  outputSchema: InjectMessageResponseSchema,
+  handler: handleInjectMessage,
+};

package/src/tools/install-node.js

@@ -0,0 +1,31 @@
+/**
+ * MCP tool: install-node
+ *
+ * Installs a new Node-RED node module from the npm registry via the Admin API's
+ * POST /nodes endpoint. Accepts a plain npm package name (no @version qualifiers
+ * — the API does not support them via JSON body). Returns the Node Module object
+ * with name, version, and the list of installed node types.
+ */
+import { formatSuccess } from './response-utils.js';
+
+
+import { ANN_INSTALL } from './constants.js';
+import { GenericObjectSchema } from '../schemas/responses.js';
+/**
+ * Handle the install-node MCP tool invocation.
+ *
+ * @param {ReturnType<import('../nodered/client.js').createNodeRedClient>} client
+ * @param {{ module: string }} params
+ * @returns {Promise<{ content: Array<{ type: string, text: string }> }>}
+ */
+export async function handleInstallNode(client, { module: moduleName }) {
+  const result = await client.request('POST', '/nodes', { module: moduleName });
+  return formatSuccess(result);
+}
+
+export const installNodeDefinition = {
+  name: 'install-node',
+  annotations: ANN_INSTALL,
+  outputSchema: GenericObjectSchema,
+  handler: handleInstallNode,
+};