@codemation/host 0.1.6 → 0.1.7

package/src/application/mapping/WorkflowDefinitionMapper.ts

@@ -1,4 +1,4 @@
-import type { AgentNodeConfig, NodeDefinition, WorkflowActivationPolicy, WorkflowDefinition } from "@codemation/core";
+import type { NodeDefinition, WorkflowActivationPolicy, WorkflowDefinition } from "@codemation/core";
 import {
   AgentConfigInspector,
   AgentConnectionNodeCollector,
@@ -30,13 +30,14 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
   }
 
   mapSync(workflow: WorkflowDefinition): WorkflowDto {
+    const mapped = this.mapNodesAndEdges(workflow);
     return {
       id: workflow.id,
       name: workflow.name,
       active: this.workflowActivationPolicy.isActive(workflow.id),
       hasWorkflowErrorHandler: this.policyUi.workflowHasErrorHandler(workflow),
-      nodes: this.toNodes(workflow),
-      edges: this.toEdges(workflow),
+      nodes: mapped.nodes,
+      edges: mapped.edges,
     };
   }
 
@@ -61,19 +62,54 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
     return map;
   }
 
-  private toNodes(workflow: WorkflowDefinition): ReadonlyArray<WorkflowNodeDto> {
+  private mapNodesAndEdges(
+    workflow: WorkflowDefinition,
+  ): Readonly<{ nodes: ReadonlyArray<WorkflowNodeDto>; edges: WorkflowDto["edges"] }> {
     const connectionChildMeta = this.buildConnectionChildMeta(workflow);
     const materializedConnectionNodeIds = new Set(connectionChildMeta.keys());
+    const nodesById = new Map(workflow.nodes.map((node) => [node.id, node] as const));
+    const agentConnectionDescriptors = this.buildAgentConnectionDescriptorIndex(workflow);
+    return {
+      nodes: this.toNodes({
+        workflow,
+        connectionChildMeta,
+        materializedConnectionNodeIds,
+        nodesById,
+        agentConnectionDescriptors,
+      }),
+      edges: this.toEdges({
+        workflow,
+        materializedConnectionNodeIds,
+        agentConnectionDescriptors,
+      }),
+    };
+  }
+
+  private toNodes(
+    args: Readonly<{
+      workflow: WorkflowDefinition;
+      connectionChildMeta: ReadonlyMap<string, Readonly<{ parentNodeId: string; connectionName: string }>>;
+      materializedConnectionNodeIds: ReadonlySet<string>;
+      nodesById: ReadonlyMap<string, WorkflowDefinition["nodes"][number]>;
+      agentConnectionDescriptors: Readonly<{
+        byAgentNodeId: ReadonlyMap<string, ReadonlyArray<AgentConnectionNodeDescriptor>>;
+        byChildNodeIdByAgentNodeId: ReadonlyMap<string, ReadonlyMap<string, AgentConnectionNodeDescriptor>>;
+      }>;
+    }>,
+  ): ReadonlyArray<WorkflowNodeDto> {
+    const workflow = args.workflow;
+    const connectionChildMeta = args.connectionChildMeta;
+    const materializedConnectionNodeIds = args.materializedConnectionNodeIds;
+    const nodesById = args.nodesById;
+    const agentConnectionDescriptors = args.agentConnectionDescriptors;
     const nodes: WorkflowNodeDto[] = [];
     for (const node of workflow.nodes) {
       const conn = connectionChildMeta.get(node.id);
       if (conn) {
-        const parentNode = workflow.nodes.find((n) => n.id === conn.parentNodeId);
+        const parentNode = nodesById.get(conn.parentNodeId);
         let role: string = conn.connectionName === "llm" ? "languageModel" : "tool";
         if (parentNode && AgentConfigInspector.isAgentNodeConfig(parentNode.config)) {
-          const descriptor = AgentConnectionNodeCollector.collect(conn.parentNodeId, parentNode.config).find(
-            (d) => d.nodeId === node.id,
-          );
+          const descriptor = agentConnectionDescriptors.byChildNodeIdByAgentNodeId.get(conn.parentNodeId)?.get(node.id);
           if (descriptor) {
             role = descriptor.role;
           }
@@ -87,6 +123,7 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
           icon: node.config?.icon,
           retryPolicySummary: this.policyUi.nodeRetrySummary(node.config),
           hasNodeErrorHandler: this.policyUi.nodeHasErrorHandler(node.config),
+          ...this.nodePortFieldsFromConfig(node.config),
           parentNodeId: conn.parentNodeId,
         });
         continue;
@@ -100,17 +137,32 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
         icon: node.config?.icon,
         retryPolicySummary: this.policyUi.nodeRetrySummary(node.config),
         hasNodeErrorHandler: this.policyUi.nodeHasErrorHandler(node.config),
+        ...this.nodePortFieldsFromConfig(node.config),
       });
       if (AgentConfigInspector.isAgentNodeConfig(node.config)) {
-        this.appendVirtualConnectionNodes(node.id, node.config, materializedConnectionNodeIds, nodes);
+        this.appendVirtualConnectionNodes(
+          materializedConnectionNodeIds,
+          nodes,
+          agentConnectionDescriptors.byAgentNodeId.get(node.id) ?? [],
+        );
       }
     }
     return nodes;
   }
 
-  private toEdges(workflow: WorkflowDefinition): WorkflowDto["edges"] {
-    const connectionChildMeta = this.buildConnectionChildMeta(workflow);
-    const materializedConnectionNodeIds = new Set(connectionChildMeta.keys());
+  private toEdges(
+    args: Readonly<{
+      workflow: WorkflowDefinition;
+      materializedConnectionNodeIds: ReadonlySet<string>;
+      agentConnectionDescriptors: Readonly<{
+        byAgentNodeId: ReadonlyMap<string, ReadonlyArray<AgentConnectionNodeDescriptor>>;
+        byChildNodeIdByAgentNodeId: ReadonlyMap<string, ReadonlyMap<string, AgentConnectionNodeDescriptor>>;
+      }>;
+    }>,
+  ): WorkflowDto["edges"] {
+    const workflow = args.workflow;
+    const materializedConnectionNodeIds = args.materializedConnectionNodeIds;
+    const agentConnectionDescriptors = args.agentConnectionDescriptors;
     const edges: WorkflowEdgeDto[] = [...workflow.edges];
     const edgeKeys = new Set(edges.map((edge) => this.edgeKey(edge.from.nodeId, edge.to.nodeId, edge.to.input)));
     this.appendMaterializedConnectionEdges(workflow, edgeKeys, edges);
@@ -118,7 +170,12 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
       if (!AgentConfigInspector.isAgentNodeConfig(node.config)) {
         continue;
       }
-      this.appendVirtualConnectionEdges(node.id, node.config, materializedConnectionNodeIds, edgeKeys, edges);
+      this.appendVirtualConnectionEdges(
+        materializedConnectionNodeIds,
+        edgeKeys,
+        edges,
+        agentConnectionDescriptors.byAgentNodeId.get(node.id) ?? [],
+      );
     }
     return edges;
   }
@@ -143,13 +200,33 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
     }
   }
 
+  private buildAgentConnectionDescriptorIndex(workflow: WorkflowDefinition): Readonly<{
+    byAgentNodeId: ReadonlyMap<string, ReadonlyArray<AgentConnectionNodeDescriptor>>;
+    byChildNodeIdByAgentNodeId: ReadonlyMap<string, ReadonlyMap<string, AgentConnectionNodeDescriptor>>;
+  }> {
+    const byAgentNodeId = new Map<string, ReadonlyArray<AgentConnectionNodeDescriptor>>();
+    const byChildNodeIdByAgentNodeId = new Map<string, ReadonlyMap<string, AgentConnectionNodeDescriptor>>();
+    for (const node of workflow.nodes) {
+      if (!AgentConfigInspector.isAgentNodeConfig(node.config)) {
+        continue;
+      }
+      const descriptors = AgentConnectionNodeCollector.collect(node.id, node.config);
+      byAgentNodeId.set(node.id, descriptors);
+      const byChildId = new Map<string, AgentConnectionNodeDescriptor>();
+      for (const descriptor of descriptors) {
+        byChildId.set(descriptor.nodeId, descriptor);
+      }
+      byChildNodeIdByAgentNodeId.set(node.id, byChildId);
+    }
+    return { byAgentNodeId, byChildNodeIdByAgentNodeId };
+  }
+
   private appendVirtualConnectionNodes(
-    rootAgentNodeId: string,
-    agentConfig: AgentNodeConfig<any, any>,
     materializedConnectionNodeIds: ReadonlySet<string>,
     nodes: WorkflowNodeDto[],
+    descriptors: ReadonlyArray<AgentConnectionNodeDescriptor>,
   ): void {
-    for (const connectionNode of AgentConnectionNodeCollector.collect(rootAgentNodeId, agentConfig)) {
+    for (const connectionNode of descriptors) {
       if (materializedConnectionNodeIds.has(connectionNode.nodeId)) {
         continue;
       }
@@ -158,13 +235,12 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
   }
 
   private appendVirtualConnectionEdges(
-    rootAgentNodeId: string,
-    agentConfig: AgentNodeConfig<any, any>,
     materializedConnectionNodeIds: ReadonlySet<string>,
     edgeKeys: Set<string>,
     edges: WorkflowEdgeDto[],
+    descriptors: ReadonlyArray<AgentConnectionNodeDescriptor>,
   ): void {
-    for (const connectionNode of AgentConnectionNodeCollector.collect(rootAgentNodeId, agentConfig)) {
+    for (const connectionNode of descriptors) {
       if (materializedConnectionNodeIds.has(connectionNode.nodeId)) {
         continue;
       }
@@ -196,6 +272,28 @@ export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition,
     };
   }
 
+  /**
+   * Omit optional port fields when undefined so persisted snapshot DTOs (which never serialize
+   * undefined keys) stay aligned with live workflow mapping.
+   */
+  private nodePortFieldsFromConfig(
+    config: NodeDefinition["config"] | undefined,
+  ): Pick<WorkflowNodeDto, "continueWhenEmptyOutput" | "declaredOutputPorts" | "declaredInputPorts"> {
+    if (!config || typeof config !== "object") {
+      return {};
+    }
+    const c = config as {
+      continueWhenEmptyOutput?: boolean;
+      declaredOutputPorts?: readonly string[];
+      declaredInputPorts?: readonly string[];
+    };
+    return {
+      ...(c.continueWhenEmptyOutput !== undefined && { continueWhenEmptyOutput: c.continueWhenEmptyOutput }),
+      ...(c.declaredOutputPorts !== undefined && { declaredOutputPorts: c.declaredOutputPorts }),
+      ...(c.declaredInputPorts !== undefined && { declaredInputPorts: c.declaredInputPorts }),
+    };
+  }
+
   private nodeTypeName(node: NodeDefinition): string {
     const configToken = node.config?.type as Readonly<{ name?: unknown }> | undefined;
     if (typeof configToken?.name === "string" && configToken.name) {

package/src/bootstrap/AppContainerFactory.ts

@@ -63,6 +63,7 @@ import {
   GetRunStateQueryHandler,
   GetWorkflowDebuggerOverlayQueryHandler,
   GetWorkflowDetailQueryHandler,
+  GetWorkflowRunDetailQueryHandler,
   GetWorkflowOverlayBinaryAttachmentQueryHandler,
   GetWorkflowSummariesQueryHandler,
   ListWorkflowRunsQueryHandler,
@@ -194,6 +195,7 @@ export class AppContainerFactory {
     VerifyUserInviteQueryHandler,
     GetRunBinaryAttachmentQueryHandler,
     GetRunStateQueryHandler,
+    GetWorkflowRunDetailQueryHandler,
     GetWorkflowDebuggerOverlayQueryHandler,
     GetWorkflowDetailQueryHandler,
     GetWorkflowOverlayBinaryAttachmentQueryHandler,

package/src/presentation/http/routeHandlers/CredentialHttpRouteHandler.ts

@@ -121,7 +121,8 @@ export class CredentialHttpRouteHandler {
 
   async getWorkflowCredentialHealth(_: Request, params: ServerHttpRouteParams): Promise<Response> {
     try {
-      return Response.json(await this.queryBus.execute(new GetWorkflowCredentialHealthQuery(params.workflowId!)));
+      const health = await this.queryBus.execute(new GetWorkflowCredentialHealthQuery(params.workflowId!));
+      return Response.json(health);
     } catch (error) {
       return ServerHttpErrorResponseFactory.fromUnknown(error);
     }

package/src/presentation/http/routeHandlers/WorkflowHttpRouteHandler.ts

@@ -66,7 +66,8 @@ export class WorkflowHttpRouteHandler {
 
   async getWorkflowRuns(_: Request, params: ServerHttpRouteParams): Promise<Response> {
     try {
-      return Response.json(await this.queryBus.execute(new ListWorkflowRunsQuery(params.workflowId!)));
+      const runs = await this.queryBus.execute(new ListWorkflowRunsQuery(params.workflowId!));
+      return Response.json(runs);
     } catch (error) {
       return ServerHttpErrorResponseFactory.fromUnknown(error);
     }
@@ -74,7 +75,8 @@ export class WorkflowHttpRouteHandler {
 
   async getWorkflowDebuggerOverlay(_: Request, params: ServerHttpRouteParams): Promise<Response> {
     try {
-      return Response.json(await this.queryBus.execute(new GetWorkflowDebuggerOverlayQuery(params.workflowId!)));
+      const overlay = await this.queryBus.execute(new GetWorkflowDebuggerOverlayQuery(params.workflowId!));
+      return Response.json(overlay);
     } catch (error) {
       return ServerHttpErrorResponseFactory.fromUnknown(error);
     }

package/src/presentation/server/CodemationConsumerConfigLoader.ts

@@ -20,6 +20,11 @@ export type CodemationConsumerConfigResolution = Readonly<{
   workflowSources: ReadonlyArray<string>;
 }>;
 
+type ConsumerImportSession = Readonly<{
+  shouldResetImporter: boolean;
+  resetCacheKeys: Set<string>;
+}>;
+
 export class CodemationConsumerConfigLoader {
   private static readonly importerRegistrationsByTsconfig = new Map<string, NamespacedUnregister>();
   private static readonly importerNamespaceVersionByTsconfig = new Map<string, number>();
@@ -38,10 +43,13 @@ export class CodemationConsumerConfigLoader {
   ): Promise<CodemationConsumerConfigResolution> {
     const loadStarted = performance.now();
     let mark = loadStarted;
+    const importSession = this.createImportSession();
+    const phaseDurations = new Map<string, number>();
     const phaseMs = (label: string): void => {
       const now = performance.now();
       const delta = now - mark;
       mark = now;
+      phaseDurations.set(label, delta);
       this.performanceDiagnosticsLogger.info(
         `load.${label} +${delta.toFixed(1)}ms (cumulative ${(now - loadStarted).toFixed(1)}ms)`,
       );
@@ -53,7 +61,7 @@ export class CodemationConsumerConfigLoader {
         'Codemation config not found. Expected "codemation.config.ts" in the consumer project root or "src/".',
       );
     }
-    const moduleExports = await this.importModule(bootstrapSource);
+    const moduleExports = await this.importModule(bootstrapSource, importSession);
     phaseMs("importConfigModule");
     const rawConfig = this.configExportsResolver.resolveConfig(moduleExports);
     if (!rawConfig) {
@@ -64,7 +72,7 @@ export class CodemationConsumerConfigLoader {
     phaseMs("resolveWorkflowSources");
     const workflows = this.mergeWorkflows(
       config.workflows ?? [],
-      await this.loadDiscoveredWorkflows(args.consumerRoot, config, workflowSources),
+      await this.loadDiscoveredWorkflows(args.consumerRoot, config, workflowSources, importSession),
     );
     phaseMs("loadDiscoveredWorkflows");
     const resolvedConfig: NormalizedCodemationConfig = {
@@ -125,6 +133,7 @@ export class CodemationConsumerConfigLoader {
     consumerRoot: string,
     config: CodemationConfig,
     workflowSources: ReadonlyArray<string>,
+    importSession: ConsumerImportSession,
   ): Promise<ReadonlyArray<WorkflowDefinition>> {
     const workflowDiscoveryDirectories = config.workflowDiscovery?.directories ?? [];
     const workflowsById = new Map<string, WorkflowDefinition>();
@@ -136,7 +145,7 @@ export class CodemationConsumerConfigLoader {
           workflowDiscoveryDirectories,
           absoluteWorkflowModulePath: workflowSource,
         }),
-        moduleExports: await this.importModule(workflowSource),
+        moduleExports: await this.importModule(workflowSource, importSession),
       })),
     );
     for (const loadedWorkflowModule of loadedWorkflowModules) {
@@ -168,13 +177,20 @@ export class CodemationConsumerConfigLoader {
     return [...workflowsById.values()];
   }
 
-  private async importModule(modulePath: string): Promise<Record<string, unknown>> {
+  private async importModule(
+    modulePath: string,
+    importSession: ConsumerImportSession,
+  ): Promise<Record<string, unknown>> {
     if (this.shouldUseNativeRuntimeImport()) {
       return await this.importModuleWithNativeRuntime(modulePath);
     }
     const tsconfigPath = await this.resolveTsconfigPath(modulePath);
-    if (this.shouldResetImporterBeforeImport()) {
+    const cacheKey = tsconfigPath || "default";
+    const shouldResetImporter = importSession.shouldResetImporter;
+    const didResetImporterForThisImport = shouldResetImporter && !importSession.resetCacheKeys.has(cacheKey);
+    if (didResetImporterForThisImport) {
       await this.resetImporter(tsconfigPath);
+      importSession.resetCacheKeys.add(cacheKey);
     }
     const importSpecifier = await this.createImportSpecifier(modulePath);
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -278,6 +294,13 @@ export class CodemationConsumerConfigLoader {
     return (process.env.CODEMATION_DEV_SERVER_TOKEN?.trim().length ?? 0) > 0;
   }
 
+  private createImportSession(): ConsumerImportSession {
+    return {
+      resetCacheKeys: new Set<string>(),
+      shouldResetImporter: this.shouldResetImporterBeforeImport(),
+    };
+  }
+
   private isStoppedTransformServiceError(error: unknown): boolean {
     return error instanceof Error && error.message.includes("The service is no longer running");
   }

package/src/presentation/server/CodemationPluginDiscovery.ts

@@ -142,14 +142,12 @@ export class CodemationPluginDiscovery {
   }
 
   private resolvePluginEntry(discoveredPackage: CodemationDiscoveredPluginPackage): string {
-    if (
+    const preferSource =
       process.env.CODEMATION_PREFER_PLUGIN_SOURCE_ENTRY === "true" &&
       typeof discoveredPackage.developmentEntry === "string" &&
-      discoveredPackage.developmentEntry.trim().length > 0
-    ) {
-      return discoveredPackage.developmentEntry;
-    }
-    return discoveredPackage.pluginEntry;
+      discoveredPackage.developmentEntry.trim().length > 0;
+    const selectedEntry = preferSource ? discoveredPackage.developmentEntry : discoveredPackage.pluginEntry;
+    return selectedEntry;
   }
 
   private async resolveDevelopmentPluginEntry(packageRoot: string): Promise<string | undefined> {