Revert "merge: main into mcp-tool-mode"

This reverts commit f80f253, reversing
changes made to 7d7836b.

Author: betterclever

backend/src/workflows/workflows.service.ts

@@ -8,7 +8,6 @@ import {
   BadRequestException,
 } from '@nestjs/common';
 import { status as grpcStatus, type ServiceError } from '@grpc/grpc-js';
-import { z } from 'zod';
 
 import { compileWorkflowGraph } from '../dsl/compiler';
 // Ensure all worker components are registered before accessing the registry
@@ -22,8 +21,6 @@ import {
 import {
   WorkflowGraphDto,
   WorkflowGraphSchema,
-  WorkflowNodeSchema,
-  WorkflowNodeDataSchema,
   ServiceWorkflowResponse,
   UpdateWorkflowMetadataDto,
 } from './dto/workflow-graph.dto';
@@ -43,7 +40,7 @@ import {
   ExecutionInputPreview,
   ExecutionTriggerMetadata,
 } from '@shipsec/shared';
-import type { WorkflowRunRecord, WorkflowVersionRecord, WorkflowGraph } from '../database/schema';
+import type { WorkflowRunRecord, WorkflowVersionRecord } from '../database/schema';
 import type { AuthContext } from '../auth/types';
 
 export interface WorkflowRunRequest {
@@ -369,155 +366,13 @@ export class WorkflowsService {
     record: WorkflowRecord,
     version?: WorkflowVersionRecord | null,
   ): ServiceWorkflowResponse {
-    // Resolve dynamic ports for the graph so Entry Point nodes show correct outputs
-    const resolvedGraph = this.resolveGraphPorts(record.graph);
-
     return {
       ...record,
-      graph: resolvedGraph,
       currentVersionId: version?.id ?? null,
       currentVersion: version?.version ?? null,
     };
   }
 
-  /**
-   * Extract component parameters from node data, handling legacy schema formats.
-   * This handles the migration from old formats where params might be at:
-   * - nodeData.config.params (current schema)
-   * - nodeData.parameters (legacy)
-   * - nodeData.config (legacy - when config was the params object directly)
-   */
-  private extractNodeParams(
-    nodeData: z.infer<typeof WorkflowNodeDataSchema>,
-  ): Record<string, unknown> {
-    // Current schema: params are in config.params
-    if (nodeData.config?.params && Object.keys(nodeData.config.params).length > 0) {
-      return nodeData.config.params;
-    }
-
-    // Legacy: params stored directly on nodeData (via extended properties)
-    const extendedNodeData = nodeData as Record<string, unknown>;
-    if (extendedNodeData.parameters && typeof extendedNodeData.parameters === 'object') {
-      return extendedNodeData.parameters as Record<string, unknown>;
-    }
-
-    // Legacy: config was the params object itself (before nested config.params structure)
-    // Only use this if config doesn't have the modern structure
-    if (
-      nodeData.config &&
-      !('params' in nodeData.config) &&
-      !('inputOverrides' in nodeData.config) &&
-      typeof nodeData.config === 'object'
-    ) {
-      return nodeData.config as Record<string, unknown>;
-    }
-
-    return {};
-  }
-
-  /**
-   * Extract component ID from node, handling frontend extensions.
-   * The componentId might be in node.type or in extended nodeData properties.
-   */
-  private extractComponentId(
-    node: z.infer<typeof WorkflowNodeSchema>,
-    nodeData: z.infer<typeof WorkflowNodeDataSchema>,
-  ): string | null {
-    // In backend schema, node.type contains the component ID
-    if (node.type && node.type !== 'workflow') {
-      return node.type;
-    }
-
-    // Frontend extensions might store componentId/componentSlug in nodeData
-    const extendedNodeData = nodeData as Record<string, unknown>;
-    if (typeof extendedNodeData.componentId === 'string') {
-      return extendedNodeData.componentId;
-    }
-    if (typeof extendedNodeData.componentSlug === 'string') {
-      return extendedNodeData.componentSlug;
-    }
-
-    return null;
-  }
-
-  /**
-   * Resolve dynamic ports for a single node based on its component and parameters.
-   */
-  private resolveNodePorts(
-    node: z.infer<typeof WorkflowNodeSchema>,
-  ): z.infer<typeof WorkflowNodeSchema> {
-    const nodeData = node.data;
-    const componentId = this.extractComponentId(node, nodeData);
-
-    if (!componentId) {
-      return node;
-    }
-
-    try {
-      const entry = componentRegistry.getMetadata(componentId);
-      if (!entry) {
-        return node;
-      }
-      const component = entry.definition;
-      const baseInputs = entry.inputs ?? extractPorts(component.inputs);
-      const baseOutputs = entry.outputs ?? extractPorts(component.outputs);
-
-      const params = this.extractNodeParams(nodeData);
-
-      if (typeof component.resolvePorts === 'function') {
-        try {
-          const resolved = component.resolvePorts(params);
-          return {
-            ...node,
-            data: {
-              ...nodeData,
-              dynamicInputs: resolved.inputs ? extractPorts(resolved.inputs) : baseInputs,
-              dynamicOutputs: resolved.outputs ? extractPorts(resolved.outputs) : baseOutputs,
-            },
-          };
-        } catch (resolveError) {
-          this.logger.warn(`Failed to resolve ports for component ${componentId}: ${resolveError}`);
-          return {
-            ...node,
-            data: {
-              ...nodeData,
-              dynamicInputs: baseInputs,
-              dynamicOutputs: baseOutputs,
-            },
-          };
-        }
-      } else {
-        return {
-          ...node,
-          data: {
-            ...nodeData,
-            dynamicInputs: baseInputs,
-            dynamicOutputs: baseOutputs,
-          },
-        };
-      }
-    } catch (error) {
-      this.logger.warn(`Failed to get component ${componentId} for port resolution: ${error}`);
-      return node;
-    }
-  }
-
-  /**
-   * Resolve dynamic ports for all nodes in a workflow graph.
-   * This ensures Entry Point nodes and other components with resolvePorts
-   * have their dynamicInputs/dynamicOutputs populated correctly.
-   */
-  private resolveGraphPorts(graph: WorkflowGraph): WorkflowGraph {
-    if (!graph || !Array.isArray(graph.nodes)) {
-      return graph;
-    }
-
-    return {
-      ...graph,
-      nodes: graph.nodes.map((node) => this.resolveNodePorts(node)),
-    };
-  }
-
   async delete(id: string, auth?: AuthContext | null): Promise<void> {
     const organizationId = await this.requireWorkflowAdmin(id, auth);
     await this.repository.delete(id, { organizationId });
@@ -1358,11 +1213,80 @@ export class WorkflowsService {
     return 0;
   }
 
-  private parse(dto: WorkflowGraphDto): WorkflowGraph {
+  private parse(dto: WorkflowGraphDto) {
     const parsed = WorkflowGraphSchema.parse(dto);
 
-    // Resolve dynamic ports for all nodes using the shared helper
-    return this.resolveGraphPorts(parsed);
+    // Resolve dynamic ports for each node based on its component and parameters
+    const nodesWithResolvedPorts = parsed.nodes.map((node) => {
+      const nodeData = node.data as any;
+      // Component ID can be in node.type, data.componentId, or data.componentSlug
+      // In the workflow graph schema, node.type contains the component ID (e.g., "security.virustotal.lookup")
+      const componentId =
+        node.type !== 'workflow' ? node.type : nodeData.componentId || nodeData.componentSlug;
+
+      if (!componentId) {
+        return node;
+      }
+
+      try {
+        const entry = componentRegistry.getMetadata(componentId);
+        if (!entry) {
+          return node;
+        }
+        const component = entry.definition;
+        const baseInputs = entry.inputs ?? extractPorts(component.inputs);
+        const baseOutputs = entry.outputs ?? extractPorts(component.outputs);
+
+        // Get parameters from node data (they may be stored in config.params, parameters, or at data level)
+        const params = nodeData.parameters || nodeData.config?.params || nodeData.config || {};
+
+        // Resolve ports using the component's resolvePorts function if available
+        if (typeof component.resolvePorts === 'function') {
+          try {
+            const resolved = component.resolvePorts(params);
+            return {
+              ...node,
+              data: {
+                ...nodeData,
+                dynamicInputs: resolved.inputs ? extractPorts(resolved.inputs) : baseInputs,
+                dynamicOutputs: resolved.outputs ? extractPorts(resolved.outputs) : baseOutputs,
+              },
+            };
+          } catch (resolveError) {
+            this.logger.warn(
+              `Failed to resolve ports for component ${componentId}: ${resolveError}`,
+            );
+            // Fall back to static metadata
+            return {
+              ...node,
+              data: {
+                ...nodeData,
+                dynamicInputs: baseInputs,
+                dynamicOutputs: baseOutputs,
+              },
+            };
+          }
+        } else {
+          // No dynamic resolver, use static metadata
+          return {
+            ...node,
+            data: {
+              ...nodeData,
+              dynamicInputs: baseInputs,
+              dynamicOutputs: baseOutputs,
+            },
+          };
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to get component ${componentId} for port resolution: ${error}`);
+        return node;
+      }
+    });
+
+    return {
+      ...parsed,
+      nodes: nodesWithResolvedPorts,
+    };
   }
 
   private formatInputSummary(inputs?: Record<string, unknown>): string {