@spinnaker/ecs 2026.2.4 → 2026.3.1

package/dist/serverGroup/configure/wizard/pages/LoggingSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const LoggingSettings: ({ command, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/NetworkingSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const NetworkingSettings: ({ command, configureCommand, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/ServiceDiscoverySettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const ServiceDiscoverySettings: ({ command, configureCommand, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/TaskDefinitionSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const TaskDefinitionSettings: ({ command, configureCommand, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/common.d.ts

@@ -0,0 +1,8 @@
+import type { Application } from '@spinnaker/core';
+import type { IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
+export interface IEcsWizardPageProps {
+    application: Application;
+    command: IEcsServerGroupCommand;
+    configureCommand: (query?: string) => Promise<void>;
+    onFieldChange: (field: string, value: any) => void;
+}

package/dist/serverGroup/configure/wizard/pages/validation.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
+type ValidationErrors = {
+    [key: string]: any;
+};
+type Validator = (values: IEcsServerGroupCommand) => ValidationErrors;
+export declare const validateEcsBasicSettings: Validator;
+export declare const validateEcsTaskDefinition: Validator;
+export declare const validateEcsContainer: Validator;
+export declare const validateEcsServiceDiscovery: Validator;
+export declare const validateEcsCapacity: Validator;
+export declare const validateEcsServerGroup: Validator;
+interface IEcsWizardPageValidationProps {
+    children: React.ReactElement;
+    validator: Validator;
+}
+export declare class EcsWizardPageValidation extends React.Component<IEcsWizardPageValidationProps> implements IWizardPageComponent<IEcsServerGroupCommand> {
+    validate: (values: IEcsServerGroupCommand) => ValidationErrors;
+    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>> | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & string) | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & number) | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & false) | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & true) | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & React.ReactElement<any, string | React.JSXElementConstructor<any>>) | (React.ReactElement<any, string | React.JSXElementConstructor<any>> & React.ReactPortal);
+}
+export {};

package/dist/serverGroup/configure/wizard/serviceDiscovery/ServiceDiscovery.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import type { IEcsServerGroupCommand, IEcsServiceDiscoveryRegistryAssociation } from '../../serverGroupConfiguration.service';
 export interface IServiceDiscoveryProps {
     command: IEcsServerGroupCommand;
-    notifyAngular: (key: string, value: any) => void;
-    configureCommand: (query: string) => PromiseLike<void>;
+    onFieldChange: (key: string, value: any) => void;
+    configureCommand: (query: string) => Promise<void>;
 }
 export interface IEcsServiceDiscoveryRegistry {
     account: string;
@@ -21,7 +21,10 @@ interface IServiceDiscoveryState {
 export declare class ServiceDiscovery extends React.Component<IServiceDiscoveryProps, IServiceDiscoveryState> {
     constructor(props: IServiceDiscoveryProps);
     componentDidMount(): void;
+    componentDidUpdate(): void;
+    private normalizeContainerNames;
     private getNameToRegistryMap;
+    private mergeRegistries;
     private getEmptyRegistry;
     private updateServiceDiscoveryRegistry;
     private updateServiceDiscoveryPort;
@@ -30,5 +33,4 @@ export declare class ServiceDiscovery extends React.Component<IServiceDiscoveryP
     private removeServiceDiscoveryAssociations;
     render(): React.ReactElement<ServiceDiscovery>;
 }
-export declare const SERVICE_DISCOVERY_REACT = "spinnaker.ecs.serverGroup.configure.wizard.serviceDiscovery.react";
 export {};

package/dist/serverGroup/configure/wizard/taskDefinition/TaskDefinition.d.ts

@@ -3,8 +3,8 @@ import type { IAccountDetails } from '@spinnaker/core';
 import type { IEcsContainerMapping, IEcsDockerImage, IEcsServerGroupCommand, IEcsTargetGroupMapping, IEcsTaskDefinitionArtifact } from '../../serverGroupConfiguration.service';
 export interface ITaskDefinitionProps {
     command: IEcsServerGroupCommand;
-    notifyAngular: (key: string, value: any) => void;
-    configureCommand: (query: string) => PromiseLike<void>;
+    onFieldChange: (key: string, value: any) => void;
+    configureCommand: (query: string) => Promise<void>;
 }
 interface ITaskDefinitionState {
     taskDefArtifact: IEcsTaskDefinitionArtifact;
@@ -22,6 +22,7 @@ export declare class TaskDefinition extends React.Component<ITaskDefinitionProps
     constructor(props: ITaskDefinitionProps);
     componentDidMount(): void;
     private updateDockerRegistryAccount;
+    componentDidUpdate(): void;
     private getIdToImageMap;
     private getEmptyImageDescription;
     private excludedArtifactTypePatterns;
@@ -39,5 +40,4 @@ export declare class TaskDefinition extends React.Component<ITaskDefinitionProps
     private updateEvaluateTaskDefArtifactFlag;
     render(): React.ReactElement<TaskDefinition>;
 }
-export declare const TASK_DEFINITION_REACT = "spinnaker.ecs.serverGroup.configure.wizard.taskDefinition.react";
 export {};

package/dist/serverGroup/details/EcsServerGroupActions.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { IRouterInjectedProps, IServerGroupActionsProps } from '@spinnaker/core';
+export declare function EcsServerGroupActionsComponent({ app, serverGroup, stateService, }: IServerGroupActionsProps & IRouterInjectedProps): JSX.Element;
+export declare const EcsServerGroupActions: React.ForwardRefExoticComponent<Omit<IServerGroupActionsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;

package/dist/serverGroup/details/ecsServerGroupDetailsGetter.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+import type { IServerGroup, IServerGroupDetailsProps } from '@spinnaker/core';
+export declare function ecsServerGroupDetailsGetter(props: IServerGroupDetailsProps, autoClose: () => void): Observable<IServerGroup>;

package/dist/serverGroup/details/resize/EcsResizeServerGroupModal.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { Application, DeckRuntimeServices, IModalComponentProps, IServerGroup, IServerGroupJob } from '@spinnaker/core';
+import { DeckRuntimeContext, TaskMonitor } from '@spinnaker/core';
+export interface IEcsResizeServerGroupModalProps extends IModalComponentProps {
+    application: Application;
+    serverGroup: IServerGroup;
+}
+export interface IEcsResizeCapacity {
+    desired: number;
+    max: number;
+    min: number;
+}
+export interface IEcsResizeServerGroupValues {
+    capacity: IEcsResizeCapacity;
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+}
+export interface IEcsResizeServerGroupJob extends IServerGroupJob {
+    capacity: IEcsResizeCapacity;
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+}
+export interface IEcsResizeServerGroupErrors {
+    capacity?: Partial<Record<keyof IEcsResizeCapacity, string>>;
+}
+interface IEcsResizeServerGroupModalState {
+    initialValues: IEcsResizeServerGroupValues;
+    taskMonitor: TaskMonitor;
+    verified: boolean;
+}
+export declare function validateEcsResizeValues(values: IEcsResizeServerGroupValues): IEcsResizeServerGroupErrors;
+export declare class EcsResizeServerGroupModal extends React.Component<IEcsResizeServerGroupModalProps, IEcsResizeServerGroupModalState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    static defaultProps: Partial<IEcsResizeServerGroupModalProps>;
+    static show(props: IEcsResizeServerGroupModalProps, runtimeServices: DeckRuntimeServices): Promise<IEcsResizeServerGroupJob>;
+    constructor(props: IEcsResizeServerGroupModalProps);
+    private close;
+    private submit;
+    private capacityError;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/details/resize/index.d.ts

@@ -0,0 +1 @@
+export * from './EcsResizeServerGroupModal';

package/dist/serverGroup/details/rollback/EcsRollbackServerGroupModal.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import type { Application, DeckRuntimeServices, IModalComponentProps, IServerGroup, IServerGroupJob } from '@spinnaker/core';
+import { DeckRuntimeContext, TaskMonitor } from '@spinnaker/core';
+export interface IEcsRollbackServerGroupModalProps extends IModalComponentProps {
+    application: Application;
+    serverGroup: IServerGroup;
+}
+export interface IEcsRollbackServerGroupValues {
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+    restoreServerGroupName?: string;
+    targetHealthyRollbackPercentage: number;
+}
+export interface IEcsRollbackServerGroupJob extends IServerGroupJob {
+    interestingHealthProviderNames?: string[];
+    platformHealthOnlyShowOverride?: boolean;
+    reason?: string;
+    rollbackContext: {
+        restoreServerGroupName: string;
+        rollbackServerGroupName: string;
+        targetHealthyRollbackPercentage: number;
+    };
+    rollbackType: 'EXPLICIT';
+}
+export interface IEcsRollbackServerGroupErrors {
+    restoreServerGroupName?: string;
+    targetHealthyRollbackPercentage?: string;
+}
+interface IEcsRollbackServerGroupModalState {
+    initialValues: IEcsRollbackServerGroupValues;
+    taskMonitor: TaskMonitor;
+    verified: boolean;
+}
+export declare function getEcsRollbackTargets(application: Application, serverGroup: IServerGroup): IServerGroup[];
+export declare function validateEcsRollbackValues(values: IEcsRollbackServerGroupValues, eligibleTargetNames?: string[]): IEcsRollbackServerGroupErrors;
+export declare class EcsRollbackServerGroupModal extends React.Component<IEcsRollbackServerGroupModalProps, IEcsRollbackServerGroupModalState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    static defaultProps: Partial<IEcsRollbackServerGroupModalProps>;
+    static show(props: IEcsRollbackServerGroupModalProps, runtimeServices: DeckRuntimeServices): Promise<IEcsRollbackServerGroupJob>;
+    constructor(props: IEcsRollbackServerGroupModalProps);
+    private close;
+    private submit;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/details/rollback/index.d.ts

@@ -0,0 +1 @@
+export * from './EcsRollbackServerGroupModal';

package/dist/serverGroup/details/sections/EcsServerGroupDetailsSections.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { IServerGroupDetailsSectionProps } from '@spinnaker/core';
+export declare function EcsTaskDefinitionSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsEnvironmentVariablesSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsHealthSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsFirewallsSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsCapacitySection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsScalingPoliciesSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;
+export declare function EcsBuildInfoSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;

package/dist/serverGroup/details/sections/EcsServerGroupEventsSection.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IServerGroupDetailsSectionProps } from '@spinnaker/core';
+export declare function EcsServerGroupEventsSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;

package/dist/serverGroup/details/sections/EcsServerGroupInformationSection.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IServerGroupDetailsSectionProps } from '@spinnaker/core';
+export declare function EcsServerGroupInformationSection({ serverGroup }: IServerGroupDetailsSectionProps): JSX.Element;

package/dist/serverGroup/events/EcsServerGroupEventsModal.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { IModalComponentProps, IServerGroup } from '@spinnaker/core';
+import type { IEventDescription } from './serverGroupEventsReader.service';
+export interface IEcsServerGroupEventsModalProps extends IModalComponentProps {
+    serverGroup: IServerGroup;
+}
+interface IEcsServerGroupEventsModalState {
+    loading: boolean;
+    error: boolean;
+    events: IEventDescription[];
+}
+export declare class EcsServerGroupEventsModal extends React.Component<IEcsServerGroupEventsModalProps, IEcsServerGroupEventsModalState> {
+    state: IEcsServerGroupEventsModalState;
+    private mounted;
+    private requestId;
+    componentDidMount(): void;
+    componentDidUpdate(previousProps: IEcsServerGroupEventsModalProps): void;
+    componentWillUnmount(): void;
+    private loadEvents;
+    render(): JSX.Element;
+}
+export {};

package/dist/serverGroup/events/EventsLink.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="react" />
 import type { IServerGroup } from '@spinnaker/core';
 export interface IViewScalingActivitiesLinkProps {
     serverGroup: IServerGroup;
 }
+export declare function EventsLink({ serverGroup }: IViewScalingActivitiesLinkProps): JSX.Element;

package/dist/serverGroup/events/serverGroupEventsReader.service.d.ts

@@ -6,5 +6,5 @@ export interface IEventDescription {
     status: string;
 }
 export declare class ServerGroupEventsReader {
-    static getEvents(serverGroup: IServerGroup): PromiseLike<IEventDescription[]>;
+    static getEvents(serverGroup: IServerGroup): Promise<IEventDescription[]>;
 }

package/dist/serverGroup/serverGroup.transformer.d.ts

@@ -4,8 +4,7 @@ export declare class EcsServerGroupTransformer {
     private addAdjustmentAttributes;
     private transformScalingPolicy;
     normalizeServerGroupDetails(serverGroup: IAmazonServerGroup): IAmazonServerGroupView;
-    normalizeServerGroup(serverGroup: IAmazonServerGroup): PromiseLike<IAmazonServerGroup>;
+    normalizeServerGroup(serverGroup: IAmazonServerGroup): Promise<IAmazonServerGroup>;
     private addVpcNameToServerGroup;
     convertServerGroupCommandToDeployConfiguration(base: any): any;
 }
-export declare const ECS_SERVER_GROUP_TRANSFORMER = "spinnaker.ecs.serverGroup.transformer";

package/dist/serviceDiscovery/serviceDiscovery.read.service.d.ts

@@ -1,4 +1,4 @@
 import type { IServiceDiscoveryRegistryDescriptor } from './IServiceDiscovery';
 export declare class ServiceDiscoveryReader {
-    static listServiceDiscoveryRegistries(): PromiseLike<IServiceDiscoveryRegistryDescriptor[]>;
+    static listServiceDiscoveryRegistries(): Promise<IServiceDiscoveryRegistryDescriptor[]>;
 }

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
   "license": "Apache-2.0",
-  "version": "2026.2.4",
+  "version": "2026.3.1",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -24,22 +24,16 @@
     "@spinnaker/amazon": "^0.14.5",
     "@spinnaker/core": "^0.29.1",
     "@spinnaker/docker": "^0.0.147",
-    "@uirouter/angularjs": "1.0.26",
     "@uirouter/react": "1.0.7",
-    "angular": "1.8.3",
-    "angular-ui-bootstrap": "2.5.0",
     "lodash": "4.18.1",
-    "ngimport": "0.6.1",
     "react": "16.14.0",
     "react-bootstrap": "0.32.1",
     "react-select": "1.2.1",
-    "react2angular": "3.2.1"
+    "rxjs": "6.6.7"
   },
   "devDependencies": {
     "@spinnaker/eslint-plugin": "^3.0.2",
     "@spinnaker/scripts": "^0.4.0",
-    "@types/angular": "1.6.26",
-    "@types/angular-ui-bootstrap": "0.13.41",
     "@types/lodash": "4.14.64",
     "@types/react": "16.14.10",
     "@types/react-bootstrap": "0.32.5",
@@ -47,5 +41,5 @@
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "f71c76e3c4b7791db81f01212e2487f1b637484c"
+  "gitHead": "edb1aa9de446184eadee134ea51110609278929f"
 }

package/src/ecs.module.spec.ts

@@ -0,0 +1,86 @@
+import { CloudProviderRegistry, Registry } from '@spinnaker/core';
+
+import { registerEcsPipelineStages } from './ecs.module';
+import { EcsSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { EcsSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { EcsServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { EcsServerGroupActions } from './serverGroup/details/EcsServerGroupActions';
+import { EcsServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+
+describe('ECS package registration', () => {
+  it('registers ECS through React components', () => {
+    expect(CloudProviderRegistry.getValue('ecs', 'serverGroup.transformer')).toBe(EcsServerGroupTransformer);
+    expect(CloudProviderRegistry.getValue('ecs', 'serverGroup.commandBuilder')).toBe(EcsServerGroupCommandBuilder);
+    expect(CloudProviderRegistry.getValue('ecs', 'serverGroup.detailsActions').displayName).toBe(
+      EcsServerGroupActions.displayName,
+    );
+    expect(CloudProviderRegistry.getValue('ecs', 'adHocInfrastructureWritesEnabled')).toBeTrue();
+    const detailsSections = CloudProviderRegistry.getValue('ecs', 'serverGroup.detailsSections');
+    expect(detailsSections.length).toBe(9);
+    expect(detailsSections.every((section: unknown) => typeof section === 'function')).toBeTrue();
+    expect(CloudProviderRegistry.getValue('ecs', 'securityGroup.reader')).toBe(EcsSecurityGroupReader);
+    expect(CloudProviderRegistry.getValue('ecs', 'securityGroup.transformer')).toBe(EcsSecurityGroupTransformer);
+    expect(
+      new (CloudProviderRegistry.getValue('ecs', 'serverGroup.commandBuilder') as any)().buildNewServerGroupCommand,
+    ).toEqual(jasmine.any(Function));
+    expect(
+      new (CloudProviderRegistry.getValue('ecs', 'securityGroup.transformer') as any)().normalizeSecurityGroup,
+    ).toEqual(jasmine.any(Function));
+    const controllerKey = 'Cont' + 'roller';
+    const templateUrlKey = 'Template' + 'Url';
+    expect(CloudProviderRegistry.getValue('ecs', `serverGroup.details${controllerKey}`)).toBeNull();
+    expect(CloudProviderRegistry.getValue('ecs', `serverGroup.details${templateUrlKey}`)).toBeNull();
+    expect(CloudProviderRegistry.getValue('ecs', `instance.details${controllerKey}`)).toBeNull();
+    expect(CloudProviderRegistry.getValue('ecs', `securityGroup.details${controllerKey}`)).toBeNull();
+  });
+
+  it('registers ECS pipeline stages directly', () => {
+    Registry.reinitialize();
+    registerEcsPipelineStages();
+    const stages = Registry.pipeline.getStageTypes();
+    expect(stages.find((stage) => stage.cloudProvider === 'ecs' && stage.provides === 'destroyServerGroup')).toEqual(
+      jasmine.objectContaining({ cloudProvider: 'ecs', provides: 'destroyServerGroup' }),
+    );
+    expect(stages.find((stage) => stage.cloudProvider === 'ecs' && stage.provides === 'resizeServerGroup')).toEqual(
+      jasmine.objectContaining({ cloudProvider: 'ecs', provides: 'resizeServerGroup' }),
+    );
+  });
+
+  it('ECS stage configs expose React components without legacy templates', () => {
+    Registry.reinitialize();
+    registerEcsPipelineStages();
+    const ecsStages = Registry.pipeline
+      .getStageTypes()
+      .filter((stage) => stage.cloudProvider === 'ecs' && stage.provides);
+
+    expect(ecsStages.map((stage) => stage.provides).sort()).toEqual([
+      'cloneServerGroup',
+      'destroyServerGroup',
+      'disableCluster',
+      'disableServerGroup',
+      'enableServerGroup',
+      'findImageFromTags',
+      'resizeServerGroup',
+      'scaleDownCluster',
+      'shrinkCluster',
+    ]);
+    ecsStages.forEach((stage) => {
+      expect(stage.component).toEqual(jasmine.any(Function));
+      expect(stage.templateUrl).toBeUndefined();
+    });
+  });
+
+  it('does not bundle ECS HTML templates', () => {
+    const ecsTemplates = require.context('./', true, /\.html$/).keys();
+
+    expect(ecsTemplates).toEqual([]);
+  });
+
+  it('normalizes ECS security groups as resolved values', async () => {
+    const securityGroup = { name: 'sg-web' };
+
+    const normalized = await new EcsSecurityGroupTransformer().normalizeSecurityGroup(securityGroup);
+
+    expect(normalized).toBe(securityGroup);
+  });
+});

package/src/ecs.module.ts

@@ -1,96 +1,68 @@
-'use strict';
-
-import { module } from 'angular';
-
+import { AWSProviderSettings } from '@spinnaker/amazon';
 import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
 
-import { COMMON_MODULE } from './common/common.module';
 import './ecs.help';
 import './ecs.settings';
-import { ECS_CLUSTER_READ_SERVICE } from './ecsCluster/ecsCluster.read.service';
-import { IAM_ROLE_READ_SERVICE } from './iamRoles/iamRole.read.service';
-import { ECS_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER } from './instance/details/instance.details.controller';
+import { EcsInstanceDetails } from './instance/details/EcsInstanceDetails';
 import { EcsLoadBalancerClusterContainer } from './loadBalancer/EcsLoadBalancerClusterContainer';
 import { EcsLoadBalancerDetails } from './loadBalancer/details/loadBalancerDetails';
 import { EcsTargetGroupDetails } from './loadBalancer/details/targetGroupDetails';
 import { EcsLoadBalancerTransformer } from './loadBalancer/loadBalancer.transformer';
-import { ECS_TARGET_GROUP_STATES } from './loadBalancer/targetGroup.states';
+import './loadBalancer/targetGroup.states';
 import ecsLogo from './logo/ecs.logo.svg';
-import { METRIC_ALARM_READ_SERVICE } from './metricAlarm/metricAlarm.read.service';
-import { ECS_PIPELINE_STAGES_DESTROYASG_ECSDESTROYASGSTAGE } from './pipeline/stages/destroyAsg/ecsDestroyAsgStage';
-import { ECS_PIPELINE_STAGES_DISABLEASG_ECSDISABLEASGSTAGE } from './pipeline/stages/disableAsg/ecsDisableAsgStage';
-import { ECS_PIPELINE_STAGES_DISABLECLUSTER_ECSDISABLECLUSTERSTAGE } from './pipeline/stages/disableCluster/ecsDisableClusterStage';
-import { ECS_PIPELINE_STAGES_ENABLEASG_ECSENABLEASGSTAGE } from './pipeline/stages/enableAsg/ecsEnableAsgStage';
-import { ECS_PIPELINE_STAGES_FINDIMAGEFROMTAGS_ECSFINDIMAGEFROMTAGSTAGE } from './pipeline/stages/findImageFromTags/ecsFindImageFromTagStage';
-import { ECS_PIPELINE_STAGES_RESIZEASG_ECSRESIZEASGSTAGE } from './pipeline/stages/resizeAsg/ecsResizeAsgStage';
-import { ECS_PIPELINE_STAGES_SCALEDOWNCLUSTER_ECSSCALEDOWNCLUSTERSTAGE } from './pipeline/stages/scaleDownCluster/ecsScaleDownClusterStage';
-import { ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE } from './pipeline/stages/shrinkCluster/ecsShrinkClusterStage';
-import { PLACEMENT_STRATEGY_SERVICE } from './placementStrategy/placementStrategy.service';
-import { ECS_SECRET_READ_SERVICE } from './secrets/secret.read.service';
-import { ECS_SECURITY_GROUP_MODULE } from './securityGroup/securityGroup.module';
-import { ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE } from './serverGroup/configure/serverGroupCommandBuilder.service';
-import { ECS_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_ECS_CONTROLLER } from './serverGroup/configure/wizard/CloneServerGroup.ecs.controller';
-import { ECS_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_ADVANCEDSETTINGS_COMPONENT } from './serverGroup/configure/wizard/advancedSettings/advancedSettings.component';
-import { ECS_CAPACITY_PROVIDER_REACT } from './serverGroup/configure/wizard/capacityProvider/CapacityProvider';
-import { CONTAINER_REACT } from './serverGroup/configure/wizard/container/Container';
-import { ECS_SERVERGROUP_CONFIGURE_WIZARD_HORIZONTALSCALING_HORIZONTALSCALING_COMPONENT } from './serverGroup/configure/wizard/horizontalScaling/horizontalScaling.component';
-import { ECS_SERVERGROUP_CONFIGURE_WIZARD_LOCATION_SERVERGROUPBASICSETTINGS_CONTROLLER } from './serverGroup/configure/wizard/location/ServerGroupBasicSettings.controller';
-import { ECS_SERVER_GROUP_LOGGING } from './serverGroup/configure/wizard/logging/logging.component';
-import { ECS_NETWORKING_REACT } from './serverGroup/configure/wizard/networking/Networking';
-import { SERVICE_DISCOVERY_REACT } from './serverGroup/configure/wizard/serviceDiscovery/ServiceDiscovery';
-import { TASK_DEFINITION_REACT } from './serverGroup/configure/wizard/taskDefinition/TaskDefinition';
-import { SERVER_GROUP_DETAILS_MODULE } from './serverGroup/details/serverGroupDetails.module';
-import { ECS_SERVERGROUP_MODULE } from './serverGroup/serverGroup.module';
-import { ECS_SERVER_GROUP_TRANSFORMER } from './serverGroup/serverGroup.transformer';
+import { registerEcsCloneServerGroupStage } from './pipeline/stages/cloneServerGroup/ecsCloneServerGroupStage';
+import { registerEcsDestroyServerGroupStage } from './pipeline/stages/destroyAsg/ecsDestroyAsgStage';
+import { registerEcsDisableServerGroupStage } from './pipeline/stages/disableAsg/ecsDisableAsgStage';
+import { registerEcsDisableClusterStage } from './pipeline/stages/disableCluster/ecsDisableClusterStage';
+import { registerEcsEnableServerGroupStage } from './pipeline/stages/enableAsg/ecsEnableAsgStage';
+import { registerEcsFindImageFromTagsStage } from './pipeline/stages/findImageFromTags/ecsFindImageFromTagStage';
+import { registerEcsResizeServerGroupStage } from './pipeline/stages/resizeAsg/ecsResizeAsgStage';
+import { registerEcsScaleDownClusterStage } from './pipeline/stages/scaleDownCluster/ecsScaleDownClusterStage';
+import { registerEcsShrinkClusterStage } from './pipeline/stages/shrinkCluster/ecsShrinkClusterStage';
+import { EcsSecurityGroupDetails } from './securityGroup/details/EcsSecurityGroupDetails';
+import { EcsSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { EcsSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { EcsServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { EcsCloneServerGroupModal } from './serverGroup/configure/wizard/EcsCloneServerGroupModal';
+import { EcsServerGroupActions } from './serverGroup/details/EcsServerGroupActions';
+import { ecsServerGroupDetailsGetter } from './serverGroup/details/ecsServerGroupDetailsGetter';
+import {
+  EcsBuildInfoSection,
+  EcsCapacitySection,
+  EcsEnvironmentVariablesSection,
+  EcsFirewallsSection,
+  EcsHealthSection,
+  EcsScalingPoliciesSection,
+  EcsTaskDefinitionSection,
+} from './serverGroup/details/sections/EcsServerGroupDetailsSections';
+import { EcsServerGroupEventsSection } from './serverGroup/details/sections/EcsServerGroupEventsSection';
+import { EcsServerGroupInformationSection } from './serverGroup/details/sections/EcsServerGroupInformationSection';
+import { EcsServerGroupTransformer } from './serverGroup/serverGroup.transformer';
 
 import './logo/ecs.logo.less';
 
-export const ECS_MODULE = 'spinnaker.ecs';
-module(ECS_MODULE, [
-  ECS_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_ECS_CONTROLLER,
-  SERVER_GROUP_DETAILS_MODULE,
-  IAM_ROLE_READ_SERVICE,
-  ECS_SERVER_GROUP_TRANSFORMER,
-  // require('./pipeline/stages/cloneServerGroup/ecsCloneServerGroupStage').name,  // TODO(Bruno Carrier): We should enable this on Clouddriver before revealing this stage
-  ECS_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_ADVANCEDSETTINGS_COMPONENT,
-  ECS_SERVERGROUP_CONFIGURE_WIZARD_HORIZONTALSCALING_HORIZONTALSCALING_COMPONENT,
-  TASK_DEFINITION_REACT,
-  CONTAINER_REACT,
-  ECS_NETWORKING_REACT,
-  SERVICE_DISCOVERY_REACT,
-  ECS_CAPACITY_PROVIDER_REACT,
-  ECS_SERVER_GROUP_LOGGING,
-  ECS_CLUSTER_READ_SERVICE,
-  ECS_SECRET_READ_SERVICE,
-  METRIC_ALARM_READ_SERVICE,
-  PLACEMENT_STRATEGY_SERVICE,
-  COMMON_MODULE,
-  ECS_SERVERGROUP_CONFIGURE_WIZARD_LOCATION_SERVERGROUPBASICSETTINGS_CONTROLLER,
-  ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE,
-  ECS_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER,
-  ECS_PIPELINE_STAGES_FINDIMAGEFROMTAGS_ECSFINDIMAGEFROMTAGSTAGE,
-  ECS_PIPELINE_STAGES_DESTROYASG_ECSDESTROYASGSTAGE,
-  ECS_PIPELINE_STAGES_DISABLEASG_ECSDISABLEASGSTAGE,
-  ECS_PIPELINE_STAGES_DISABLECLUSTER_ECSDISABLECLUSTERSTAGE,
-  ECS_PIPELINE_STAGES_ENABLEASG_ECSENABLEASGSTAGE,
-  ECS_PIPELINE_STAGES_RESIZEASG_ECSRESIZEASGSTAGE,
-  ECS_PIPELINE_STAGES_SCALEDOWNCLUSTER_ECSSCALEDOWNCLUSTERSTAGE,
-  ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE,
-  ECS_SECURITY_GROUP_MODULE,
-  ECS_SERVERGROUP_MODULE,
-  ECS_TARGET_GROUP_STATES,
-]).config(function () {
+export function registerEcsProvider(): void {
   CloudProviderRegistry.registerProvider('ecs', {
     name: 'EC2 Container Service',
+    adHocInfrastructureWritesEnabled: AWSProviderSettings.adHocInfraWritesEnabled,
     logo: { path: ecsLogo },
     serverGroup: {
-      transformer: 'ecsServerGroupTransformer',
-      detailsTemplateUrl: require('./serverGroup/details/serverGroupDetails.html'),
-      detailsController: 'ecsServerGroupDetailsCtrl',
-      cloneServerGroupTemplateUrl: require('./serverGroup/configure/wizard/serverGroupWizard.html'),
-      cloneServerGroupController: 'ecsCloneServerGroupCtrl',
-      commandBuilder: 'ecsServerGroupCommandBuilder',
-      // configurationService: 'ecsServerGroupConfigurationService',
+      transformer: EcsServerGroupTransformer,
+      detailsActions: EcsServerGroupActions,
+      detailsGetter: ecsServerGroupDetailsGetter,
+      detailsSections: [
+        EcsServerGroupInformationSection,
+        EcsTaskDefinitionSection,
+        EcsEnvironmentVariablesSection,
+        EcsHealthSection,
+        EcsFirewallsSection,
+        EcsCapacitySection,
+        EcsScalingPoliciesSection,
+        EcsBuildInfoSection,
+        EcsServerGroupEventsSection,
+      ],
+      CloneServerGroupModal: EcsCloneServerGroupModal,
+      commandBuilder: EcsServerGroupCommandBuilder,
       scalingActivitiesEnabled: false,
       skipUpstreamStageCheck: true,
     },
@@ -101,16 +73,28 @@ module(ECS_MODULE, [
       details: EcsLoadBalancerDetails,
     },
     instance: {
-      detailsTemplateUrl: require('./instance/details/instanceDetails.html'),
-      detailsController: 'ecsInstanceDetailsCtrl',
+      details: EcsInstanceDetails,
     },
     securityGroup: {
-      transformer: 'ecsSecurityGroupTransformer',
-      reader: 'ecsSecurityGroupReader',
-      detailsTemplateUrl: require('./securityGroup/details/securityGroupDetail.html'),
-      detailsController: 'ecsSecurityGroupDetailsCtrl',
+      transformer: EcsSecurityGroupTransformer,
+      reader: EcsSecurityGroupReader,
+      details: EcsSecurityGroupDetails,
     },
   });
-});
+}
+
+export function registerEcsPipelineStages(): void {
+  registerEcsCloneServerGroupStage();
+  registerEcsDestroyServerGroupStage();
+  registerEcsDisableServerGroupStage();
+  registerEcsDisableClusterStage();
+  registerEcsEnableServerGroupStage();
+  registerEcsFindImageFromTagsStage();
+  registerEcsResizeServerGroupStage();
+  registerEcsScaleDownClusterStage();
+  registerEcsShrinkClusterStage();
+}
 
+registerEcsProvider();
+registerEcsPipelineStages();
 DeploymentStrategyRegistry.registerProvider('ecs', ['redblack']);

package/src/ecsCluster/ecsCluster.read.service.ts

@@ -1,23 +1,17 @@
-import { module } from 'angular';
-
 import { REST } from '@spinnaker/core';
 
 import type { IEcsCapacityProviderDetails } from './IEcsCapacityProviderDetails';
 import type { IEcsClusterDescriptor } from './IEcsCluster';
 
 export class EcsClusterReader {
-  public listClusters(): PromiseLike<IEcsClusterDescriptor[]> {
+  public listClusters(): Promise<IEcsClusterDescriptor[]> {
     return REST('/ecs/ecsClusters').get();
   }
 
-  public describeClusters(account: string, region: string): PromiseLike<IEcsCapacityProviderDetails[]> {
+  public describeClusters(account: string, region: string): Promise<IEcsCapacityProviderDetails[]> {
     if (account != null && region != null) {
       return REST('/ecs/ecsClusterDescriptions').path(account).path(region).get();
     }
-    return {} as PromiseLike<IEcsCapacityProviderDetails[]>;
+    return Promise.resolve([]);
   }
 }
-
-export const ECS_CLUSTER_READ_SERVICE = 'spinnaker.ecs.ecsCluster.read.service';
-
-module(ECS_CLUSTER_READ_SERVICE, []).service('ecsClusterReader', EcsClusterReader);