@spinnaker/appengine 2026.2.2 → 2026.3.0

package/dist/instance/details/AppengineInstanceDetails.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+interface IAppengineInstanceDetailsProps {
+    instance: {
+        account: string;
+        instanceId: string;
+        provider: string;
+        region: string;
+    };
+}
+export declare function AppengineInstanceDetails({ instance }: IAppengineInstanceDetailsProps): JSX.Element;
+export {};

package/dist/loadBalancer/configure/AppengineCreateLoadBalancerModal.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAppengineLoadBalancer } from '../../domain';
+import type { IAppengineAllocationDescription } from '../transformer';
+export declare function updateAllocationLocatorType(allocation: IAppengineAllocationDescription, locatorType: IAppengineAllocationDescription['locatorType']): IAppengineAllocationDescription;
+interface IAppengineCreateLoadBalancerModalState {
+    taskMonitor: TaskMonitor;
+}
+export declare class AppengineCreateLoadBalancerModal extends React.Component<ILoadBalancerModalProps, IAppengineCreateLoadBalancerModalState> {
+    static defaultProps: Partial<ILoadBalancerModalProps>;
+    static show(props: ILoadBalancerModalProps & {
+        isNew?: boolean;
+    }): Promise<IAppengineLoadBalancer>;
+    state: IAppengineCreateLoadBalancerModalState;
+    private command;
+    private buildInitialCommand;
+    private update;
+    private updateSplit;
+    private updateAllocation;
+    private updateAllocationLocatorType;
+    private addAllocation;
+    private removeAllocation;
+    private allocationTotal;
+    private submit;
+    private renderAllocationTarget;
+    render(): JSX.Element;
+}
+export {};

package/dist/loadBalancer/details/AppengineLoadBalancerActions.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { ILoadBalancerActionsProps } from '@spinnaker/core';
+export declare function canDeleteAppengineLoadBalancer(loadBalancer: any): boolean;
+export declare function getDeleteLoadBalancerWarning(loadBalancer: any): string;
+export declare function AppengineLoadBalancerActions({ app, loadBalancer }: ILoadBalancerActionsProps): JSX.Element;

package/dist/loadBalancer/details/AppengineLoadBalancerDetailsSection.d.ts

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

package/dist/loadBalancer/details/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AppengineLoadBalancerActions';
+export * from './AppengineLoadBalancerDetailsSection';
+export * from './useAppengineLoadBalancerDetails';

package/dist/loadBalancer/details/useAppengineLoadBalancerDetails.d.ts

@@ -0,0 +1,3 @@
+import type { IUseDetailsHookProps, UseDetailsResult } from '@spinnaker/core';
+import type { IAppengineLoadBalancer } from '../../domain';
+export declare function useAppengineLoadBalancerDetails({ app, loadBalancerParams, autoClose, }: IUseDetailsHookProps): UseDetailsResult<IAppengineLoadBalancer>;

package/dist/loadBalancer/transformer.d.ts

@@ -28,13 +28,9 @@ export declare class AppengineLoadBalancerUpsertDescription implements ILoadBala
     mapAllocationsToPercentages(): void;
 }
 export declare class AppengineLoadBalancerTransformer {
-    private $q;
-    static $inject: string[];
-    constructor($q: ng.IQService);
-    normalizeLoadBalancer(loadBalancer: ILoadBalancer): PromiseLike<ILoadBalancer>;
-    convertLoadBalancerForEditing(loadBalancer: IAppengineLoadBalancer, application: Application): PromiseLike<IAppengineLoadBalancer>;
+    normalizeLoadBalancer(loadBalancer: ILoadBalancer): Promise<ILoadBalancer>;
+    convertLoadBalancerForEditing(loadBalancer: IAppengineLoadBalancer, application: Application): Promise<IAppengineLoadBalancer>;
     convertLoadBalancerToUpsertDescription(loadBalancer: IAppengineLoadBalancer): AppengineLoadBalancerUpsertDescription;
     private buildInstanceCounts;
     private transformInstance;
 }
-export declare const APPENGINE_LOAD_BALANCER_TRANSFORMER = "spinnaker.appengine.loadBalancer.transformer.service";

package/dist/pipeline/stages/AppengineExecutionDetails.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { IExecutionDetailsSectionProps } from '@spinnaker/core';
+export declare function getServerGroupDisplayName(context: any): string;
+export declare function AppengineStartServerGroupExecutionDetails(props: IExecutionDetailsSectionProps): JSX.Element;
+export declare namespace AppengineStartServerGroupExecutionDetails {
+    var title: string;
+}
+export declare function AppengineStopServerGroupExecutionDetails(props: IExecutionDetailsSectionProps): JSX.Element;
+export declare namespace AppengineStopServerGroupExecutionDetails {
+    var title: string;
+}
+export declare function AppengineEditLoadBalancerExecutionDetails(props: IExecutionDetailsSectionProps): JSX.Element;
+export declare namespace AppengineEditLoadBalancerExecutionDetails {
+    var title: string;
+}

package/dist/pipeline/stages/AppengineServerGroupStageConfig.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { IStageConfigProps } from '@spinnaker/core';
+import type { IAppengineAccount } from '../../domain';
+export declare function getAppengineAccountRegion(accounts: IAppengineAccount[], credentials: string): string;
+export declare function initializeAppengineServerGroupStage(stage: any, application: any): void;
+type AppengineStageConfigProps = Pick<IStageConfigProps, 'application' | 'pipeline' | 'stage' | 'updateStage'> & {
+    showHealthOverride?: boolean;
+};
+export declare function AppengineServerGroupStageConfig({ application, pipeline, stage, updateStage, showHealthOverride, }: AppengineStageConfigProps): JSX.Element;
+export declare function AppengineServerGroupStageConfigWithHealthOverride(props: AppengineStageConfigProps): JSX.Element;
+export declare function AppengineShrinkClusterStageConfig({ application, pipeline, stage, updateStage, }: AppengineStageConfigProps): JSX.Element;
+export {};

package/dist/pipeline/stages/destroyAsg/appengineDestroyAsgStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_DESTROY_ASG_STAGE = "spinnaker.appengine.pipeline.stage.destroyAsgStage";
+export {};

package/dist/pipeline/stages/disableAsg/appengineDisableAsgStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_DISABLE_ASG_STAGE = "spinnaker.appengine.pipeline.stage.disableAsgStage";
+export {};

package/dist/pipeline/stages/editLoadBalancer/AppengineEditLoadBalancerStageConfig.d.ts

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

package/dist/pipeline/stages/editLoadBalancer/appengineEditLoadBalancerStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_EDIT_LOAD_BALANCER_STAGE = "spinnaker.appengine.pipeline.stage.editLoadBalancerStage";
+export {};

package/dist/pipeline/stages/enableAsg/appengineEnableAsgStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_ENABLE_ASG_STAGE = "spinnaker.appengine.pipeline.stage.enableAsgStage";
+export {};

package/dist/pipeline/stages/shrinkCluster/appengineShrinkClusterStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_SHRINK_CLUSTER_STAGE = "spinnaker.appengine.pipeline.stage.shrinkClusterStage";
+export {};

package/dist/pipeline/stages/startServerGroup/appengineStartServerGroupStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_START_SERVER_GROUP_STAGE = "spinnaker.appengine.pipeline.stage.startServerGroupStage";
+export {};

package/dist/pipeline/stages/stopServerGroup/appengineStopServerGroupStage.d.ts

@@ -1 +1 @@
-export declare const APPENGINE_STOP_SERVER_GROUP_STAGE = "spinnaker.appengine.pipeline.stage.stopServerGroupStage";
+export {};

package/dist/serverGroup/configure/serverGroupCommandBuilder.service.d.ts

@@ -1,4 +1,3 @@
-import type { IQService } from 'angular';
 import type { Application, IArtifact, IArtifactAccountPair, IExpectedArtifact, IPipeline, IStage } from '@spinnaker/core';
 import type { GitCredentialType, IAppengineGitTrigger, IAppengineJenkinsTrigger, IAppengineServerGroup } from '../../domain';
 import type { AppengineDeployDescription } from '../transformer';
@@ -49,14 +48,11 @@ export interface IViewState {
     pipeline?: IPipeline;
 }
 export declare class AppengineServerGroupCommandBuilder {
-    private $q;
     private static getTriggerOptions;
     private static getExpectedArtifacts;
-    static $inject: string[];
-    constructor($q: IQService);
-    buildNewServerGroupCommand(app: Application, selectedProvider: string, mode?: string): PromiseLike<IAppengineServerGroupCommand>;
-    buildServerGroupCommandFromExisting(app: Application, serverGroup: IAppengineServerGroup): PromiseLike<IAppengineServerGroupCommand>;
-    buildNewServerGroupCommandForPipeline(_stage: IStage, pipeline: IPipeline): PromiseLike<{
+    buildNewServerGroupCommand(app: Application, selectedProvider: string, mode?: string): Promise<IAppengineServerGroupCommand>;
+    buildServerGroupCommandFromExisting(app: Application, serverGroup: IAppengineServerGroup): Promise<IAppengineServerGroupCommand>;
+    buildNewServerGroupCommandForPipeline(_stage: IStage, pipeline: IPipeline): Promise<{
         viewState: {
             stage: IStage;
             pipeline: IPipeline;
@@ -66,9 +62,9 @@ export declare class AppengineServerGroupCommandBuilder {
             expectedArtifacts: IExpectedArtifact[];
         };
     }>;
-    buildServerGroupCommandFromPipeline(app: Application, cluster: AppengineDeployDescription, _stage: IStage, pipeline: IPipeline): PromiseLike<IAppengineServerGroupCommand>;
+    buildServerGroupCommandFromPipeline(app: Application, cluster: AppengineDeployDescription, _stage: IStage, pipeline: IPipeline): Promise<IAppengineServerGroupCommand>;
     private getCredentials;
     private getRegion;
     private getSubmitButtonLabel;
+    private resolveAll;
 }
-export declare const APPENGINE_SERVER_GROUP_COMMAND_BUILDER = "spinnaker.appengine.serverGroupCommandBuilder.service";

package/dist/serverGroup/configure/wizard/AppengineCloneServerGroupModal.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAppengineServerGroupCommand } from '../serverGroupCommandBuilder.service';
+export interface IAppengineCloneServerGroupModalProps extends Partial<IModalComponentProps> {
+    application: Application;
+    command: IAppengineServerGroupCommand;
+    title: string;
+}
+interface IAppengineCloneServerGroupModalState {
+    taskMonitor: TaskMonitor;
+}
+export declare function normalizeAppengineServerGroupCommandForSubmit(command: IAppengineServerGroupCommand): IAppengineServerGroupCommand;
+export declare class AppengineCloneServerGroupModal extends React.Component<IAppengineCloneServerGroupModalProps, IAppengineCloneServerGroupModalState> {
+    static defaultProps: Partial<IAppengineCloneServerGroupModalProps>;
+    static show(props: IAppengineCloneServerGroupModalProps): Promise<IAppengineServerGroupCommand>;
+    state: IAppengineCloneServerGroupModalState;
+    private update;
+    private submit;
+    render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { IServerGroup, IServerGroupActionsProps } from '@spinnaker/core';
+import type { IAppengineServerGroup } from '../../domain';
+export declare function canStartOrStopServerGroup(serverGroup: IAppengineServerGroup): boolean;
+export declare function canStartServerGroup(serverGroup: IAppengineServerGroup): boolean;
+export declare function canStopServerGroup(serverGroup: IAppengineServerGroup): boolean;
+export declare function expectedAllocationsAfterDisableOperation(serverGroup: IServerGroup, loadBalancers?: any[]): {
+    [key: string]: number;
+};
+export declare function canDisableServerGroup(serverGroup: IAppengineServerGroup, loadBalancers?: any[]): boolean;
+export declare function canDestroyServerGroup(serverGroup: IAppengineServerGroup, loadBalancers?: any[]): boolean;
+export declare function AppengineServerGroupActions({ app, serverGroup }: IServerGroupActionsProps): JSX.Element;

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

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

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

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import type { IServerGroupDetailsProps } from '@spinnaker/core';
+import type { IAppengineServerGroup } from '../../domain';
+export declare function appengineServerGroupDetailsGetter(props: IServerGroupDetailsProps, autoClose: () => void): Observable<IAppengineServerGroup>;

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

@@ -0,0 +1,3 @@
+export * from './AppengineServerGroupActions';
+export * from './AppengineServerGroupDetailsSection';
+export * from './appengineServerGroupDetailsGetter';

package/dist/serverGroup/transformer.d.ts

@@ -36,10 +36,6 @@ export declare class AppengineDeployDescription {
     constructor(command: IAppengineServerGroupCommand);
 }
 export declare class AppengineServerGroupTransformer {
-    private $q;
-    static $inject: string[];
-    constructor($q: ng.IQService);
-    normalizeServerGroup(serverGroup: IServerGroup): PromiseLike<IServerGroup>;
+    normalizeServerGroup(serverGroup: IServerGroup): Promise<IServerGroup>;
     convertServerGroupCommandToDeployConfiguration(command: IAppengineServerGroupCommand): AppengineDeployDescription;
 }
-export declare const APPENGINE_SERVER_GROUP_TRANSFORMER = "spinnaker.appengine.serverGroup.transformer.service";

package/dist/serverGroup/writer/serverGroup.write.service.d.ts

@@ -1,8 +1,19 @@
-import type { Application, ITask } from '@spinnaker/core';
+import type { Application, IJob, ITask } from '@spinnaker/core';
+import type { IAppengineServerGroupCommand } from '../configure/serverGroupCommandBuilder.service';
 import type { IAppengineServerGroup } from '../../domain/index';
+interface IAppengineServerGroupWriteJob extends IJob {
+    serverGroupName: string;
+    region: string;
+    credentials: string;
+    cloudProvider: string;
+}
 export declare class AppengineServerGroupWriter {
-    startServerGroup(serverGroup: IAppengineServerGroup, application: Application): PromiseLike<ITask>;
-    stopServerGroup(serverGroup: IAppengineServerGroup, application: Application): PromiseLike<ITask>;
+    cloneServerGroup(command: IAppengineServerGroupCommand, application: Application): Promise<ITask>;
+    startServerGroup(serverGroup: IAppengineServerGroup, application: Application): Promise<ITask>;
+    stopServerGroup(serverGroup: IAppengineServerGroup, application: Application): Promise<ITask>;
+    enableServerGroup(serverGroup: IAppengineServerGroup, application: Application, params?: Partial<IAppengineServerGroupWriteJob>): Promise<ITask>;
+    disableServerGroup(serverGroup: IAppengineServerGroup, application: Application, params?: Partial<IAppengineServerGroupWriteJob>): Promise<ITask>;
+    destroyServerGroup(serverGroup: IAppengineServerGroup, application: Application, params?: Partial<IAppengineServerGroupWriteJob>): Promise<ITask>;
     private buildJob;
 }
-export declare const APPENGINE_SERVER_GROUP_WRITER = "spinnaker.appengine.serverGroup.write.service";
+export {};

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
   "license": "Apache-2.0",
-  "version": "2026.2.2",
+  "version": "2026.3.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -22,29 +22,25 @@
   },
   "dependencies": {
     "@spinnaker/core": "^0.29.1",
-    "@uirouter/angularjs": "1.0.26",
-    "angular": "1.8.3",
-    "angular-ui-bootstrap": "2.5.0",
     "classnames": "2.2.6",
     "enzyme": "3.11.0",
     "formik": "1.5.1",
     "lodash": "4.18.1",
     "react": "16.14.0",
-    "react2angular": "3.2.1",
+    "react-bootstrap": "0.32.1",
     "rxjs": "6.6.7"
   },
   "devDependencies": {
     "@spinnaker/eslint-plugin": "^3.0.2",
     "@spinnaker/mocks": "1.0.7",
     "@spinnaker/scripts": "^0.4.0",
-    "@types/angular": "1.6.26",
-    "@types/angular-ui-bootstrap": "0.13.41",
     "@types/classnames": "2.2.0",
     "@types/enzyme": "3.10.3",
     "@types/lodash": "4.14.64",
     "@types/react": "16.14.10",
+    "@types/react-bootstrap": "0.32.5",
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "db086c61529c9421e8c0c2d4a2b8eca88c675ac8"
+  "gitHead": "0f7d75f5d4b42c1675e2ecc69a53f8eb73090eb9"
 }

package/src/appengine.module.spec.ts

@@ -0,0 +1,194 @@
+import { CloudProviderRegistry, DeploymentStrategyRegistry, Registry, TaskExecutor } from '@spinnaker/core';
+
+import './index';
+import { AppengineInstanceDetails } from './instance/details/AppengineInstanceDetails';
+import {
+  AppengineCreateLoadBalancerModal,
+  updateAllocationLocatorType,
+} from './loadBalancer/configure/AppengineCreateLoadBalancerModal';
+import {
+  AppengineLoadBalancerActions,
+  AppengineLoadBalancerDetailsSection,
+  canDeleteAppengineLoadBalancer,
+  getDeleteLoadBalancerWarning,
+  useAppengineLoadBalancerDetails,
+} from './loadBalancer/details';
+import { AppengineLoadBalancerTransformer } from './loadBalancer/transformer';
+import { getServerGroupDisplayName } from './pipeline/stages/AppengineExecutionDetails';
+import { getAppengineAccountRegion } from './pipeline/stages/AppengineServerGroupStageConfig';
+import {
+  AppengineCloneServerGroupModal,
+  normalizeAppengineServerGroupCommandForSubmit,
+} from './serverGroup/configure/wizard/AppengineCloneServerGroupModal';
+import { AppengineServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import {
+  AppengineServerGroupActions,
+  appengineServerGroupDetailsGetter,
+  AppengineServerGroupDetailsSection,
+  canDestroyServerGroup,
+  canDisableServerGroup,
+  canStartServerGroup,
+  canStopServerGroup,
+  expectedAllocationsAfterDisableOperation,
+} from './serverGroup/details';
+import { AppengineServerGroupTransformer } from './serverGroup/transformer';
+import { AppengineServerGroupWriter } from './serverGroup/writer/serverGroup.write.service';
+
+describe('App Engine provider registration', () => {
+  it('registers provider configuration from the package entrypoint', () => {
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.transformer')).toBe(
+      AppengineServerGroupTransformer,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.commandBuilder')).toBe(
+      AppengineServerGroupCommandBuilder,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'loadBalancer.transformer')).toBe(
+      AppengineLoadBalancerTransformer,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'instance.details')).toBe(AppengineInstanceDetails);
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.detailsActions')).toBe(AppengineServerGroupActions);
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.detailsGetter')).toBe(
+      appengineServerGroupDetailsGetter,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.detailsSections')).toEqual([
+      AppengineServerGroupDetailsSection,
+    ]);
+    expect(CloudProviderRegistry.getValue('appengine', 'serverGroup.CloneServerGroupModal')).toBe(
+      AppengineCloneServerGroupModal,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'loadBalancer.useDetailsHook')).toBe(
+      useAppengineLoadBalancerDetails,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'loadBalancer.detailsActions')).toBe(
+      AppengineLoadBalancerActions,
+    );
+    expect(CloudProviderRegistry.getValue('appengine', 'loadBalancer.detailsSections')).toEqual([
+      AppengineLoadBalancerDetailsSection,
+    ]);
+    expect(CloudProviderRegistry.getValue('appengine', 'loadBalancer.CreateLoadBalancerModal')).toBe(
+      AppengineCreateLoadBalancerModal,
+    );
+    expect(DeploymentStrategyRegistry.listStrategies('appengine').map((strategy) => strategy.key)).toContain('custom');
+  });
+
+  it('registers App Engine pipeline stages with React components', () => {
+    [
+      'enableServerGroup',
+      'disableServerGroup',
+      'destroyServerGroup',
+      'shrinkCluster',
+      'startAppEngineServerGroup',
+      'stopAppEngineServerGroup',
+      'upsertAppEngineLoadBalancers',
+      'deployAppEngineConfiguration',
+    ].forEach((type) => {
+      const stageConfig = Registry.pipeline.getStageConfig({ type, cloudProvider: 'appengine' } as any);
+      expect(stageConfig).toBeDefined();
+      expect(stageConfig.component).toBeDefined();
+    });
+
+    expect(
+      Registry.pipeline
+        .getStageConfig({ type: 'startAppEngineServerGroup', cloudProvider: 'appengine' } as any)
+        .executionDetailsSections.map((section: any) => section.title),
+    ).toEqual(['startServerGroupConfig', 'taskStatus']);
+    expect(
+      Registry.pipeline
+        .getStageConfig({ type: 'stopAppEngineServerGroup', cloudProvider: 'appengine' } as any)
+        .executionDetailsSections.map((section: any) => section.title),
+    ).toEqual(['stopServerGroupConfig', 'taskStatus']);
+    expect(
+      Registry.pipeline
+        .getStageConfig({ type: 'upsertAppEngineLoadBalancers', cloudProvider: 'appengine' } as any)
+        .executionDetailsSections.map((section: any) => section.title),
+    ).toEqual(['editLoadBalancerConfig', 'taskStatus']);
+  });
+
+  it('keeps start and stop actions eligible only for supported App Engine server groups', () => {
+    expect(canStartServerGroup({ env: 'FLEXIBLE', servingStatus: 'STOPPED' } as any)).toBe(true);
+    expect(
+      canStartServerGroup({ env: 'STANDARD', scalingPolicy: { type: 'AUTOMATIC' }, servingStatus: 'STOPPED' } as any),
+    ).toBe(false);
+    expect(
+      canStopServerGroup({ env: 'STANDARD', scalingPolicy: { type: 'BASIC' }, servingStatus: 'SERVING' } as any),
+    ).toBe(true);
+    expect(canStopServerGroup({ env: 'FLEXIBLE', servingStatus: 'STOPPED' } as any)).toBe(false);
+  });
+
+  it('keeps App Engine clone submissions on createServerGroup', () => {
+    const executeTask = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({}) as any);
+    const writer = new AppengineServerGroupWriter();
+
+    writer.cloneServerGroup(
+      {
+        application: 'myapp',
+        credentials: 'test',
+        region: 'europe-west1',
+        viewState: { mode: 'clone' },
+        configArtifacts: [],
+        configFilepaths: [],
+        configFiles: [],
+        interestingHealthProviderNames: [],
+      } as any,
+      { name: 'myapp' } as any,
+    );
+
+    expect(executeTask.calls.mostRecent().args[0].job[0].type).toBe('createServerGroup');
+  });
+
+  it('keeps disable server group task ownership on the application object', () => {
+    const executeTask = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({}) as any);
+    const writer = new AppengineServerGroupWriter();
+    const application = { name: 'myapp' } as any;
+
+    writer.disableServerGroup({ name: 'myapp-v001', region: 'europe-west1', account: 'test' } as any, application);
+
+    expect(executeTask.calls.mostRecent().args[0].application).toBe(application);
+  });
+
+  it('restores App Engine server group action eligibility from traffic allocations', () => {
+    const serverGroup = { name: 'app-v001', disabled: false } as any;
+    const loadBalancers = [{ split: { shardBy: 'IP', allocations: { 'app-v001': 0.4, 'app-v002': 0.6 } } }];
+
+    expect(expectedAllocationsAfterDisableOperation(serverGroup, loadBalancers)).toEqual({ 'app-v002': 1 });
+    expect(canDisableServerGroup(serverGroup, loadBalancers)).toBe(true);
+    expect(canDestroyServerGroup(serverGroup, loadBalancers)).toBe(true);
+    expect(canDisableServerGroup({ ...serverGroup, disabled: true }, loadBalancers)).toBe(false);
+  });
+
+  it('restores App Engine load balancer delete availability and warnings', () => {
+    expect(canDeleteAppengineLoadBalancer({ name: 'default' })).toBe(false);
+    expect(canDeleteAppengineLoadBalancer({ name: 'service-a' })).toBe(true);
+    expect(getDeleteLoadBalancerWarning({ name: 'service-a', serverGroups: [{ name: 'service-a-v001' }] })).toContain(
+      'will destroy <b>service-a-v001</b>',
+    );
+  });
+
+  it('defaults App Engine clone command arrays before submit', () => {
+    const command = normalizeAppengineServerGroupCommandForSubmit({ viewState: { mode: 'clone' } } as any);
+
+    expect(command.configArtifacts).toEqual([]);
+    expect(command.configFilepaths).toEqual([]);
+    expect(command.configFiles).toEqual([]);
+    expect(command.interestingHealthProviderNames).toEqual([]);
+    expect(command.fromArtifact).toBe(false);
+    expect(command.sourceType).toBe('git');
+  });
+
+  it('keeps pipeline load balancer allocations able to target dynamic coordinates', () => {
+    const allocation = updateAllocationLocatorType(
+      { allocation: 50, locatorType: 'text', serverGroupName: '${sg}' },
+      'targetCoordinate',
+    );
+
+    expect(allocation.locatorType).toBe('targetCoordinate');
+    expect(allocation.serverGroupName).toBeUndefined();
+    expect(allocation.target).toBe('current_asg_dynamic');
+  });
+
+  it('resolves App Engine stage region from selected account and shows ad-hoc server group names', () => {
+    expect(getAppengineAccountRegion([{ name: 'prod', region: 'europe-west1' }] as any, 'prod')).toBe('europe-west1');
+    expect(getServerGroupDisplayName({ serverGroupName: 'my-app-v001' })).toBe('my-app-v001');
+    expect(getServerGroupDisplayName({ cluster: 'my-app', serverGroupName: 'my-app-v001' })).toBe('my-app');
+  });
+});

package/src/appengine.module.ts

@@ -1,70 +1,59 @@
-import { module } from 'angular';
-
 import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
 
-import { APPENGINE_COMPONENT_URL_DETAILS } from './common/componentUrlDetails.component';
-import { APPENGINE_CONDITIONAL_DESCRIPTION_LIST_ITEM } from './common/conditionalDescriptionListItem.component';
-import { APPENGINE_LOAD_BALANCER_CREATE_MESSAGE } from './common/loadBalancerMessage.component';
 import './helpContents/appengineHelpContents';
-import { APPENGINE_INSTANCE_DETAILS_CTRL } from './instance/details/details.controller';
-import { APPENGINE_LOAD_BALANCER_MODULE } from './loadBalancer/loadBalancer.module';
+import { AppengineInstanceDetails } from './instance/details/AppengineInstanceDetails';
+import { AppengineCreateLoadBalancerModal } from './loadBalancer/configure/AppengineCreateLoadBalancerModal';
+import {
+  AppengineLoadBalancerActions,
+  AppengineLoadBalancerDetailsSection,
+  useAppengineLoadBalancerDetails,
+} from './loadBalancer/details';
+import { AppengineLoadBalancerTransformer } from './loadBalancer/transformer';
 import logo from './logo/appengine.logo.png';
-import { APPENGINE_PIPELINE_MODULE } from './pipeline/pipeline.module';
 import './pipeline/stages/deployAppengineConfig/deployAppengineConfigStage';
-import { APPENGINE_SERVER_GROUP_COMMAND_BUILDER } from './serverGroup/configure/serverGroupCommandBuilder.service';
-import { APPENGINE_SERVER_GROUP_BASIC_SETTINGS_CTRL } from './serverGroup/configure/wizard/basicSettings.controller';
-import { APPENGINE_CLONE_SERVER_GROUP_CTRL } from './serverGroup/configure/wizard/cloneServerGroup.controller';
-import { CONFIG_FILE_ARTIFACT_LIST } from './serverGroup/configure/wizard/configFileArtifactList.module';
-import { APPENGINE_SERVER_GROUP_DETAILS_CTRL } from './serverGroup/details/details.controller';
-import { APPENGINE_SERVER_GROUP_TRANSFORMER } from './serverGroup/transformer';
-import { APPENGINE_SERVER_GROUP_WRITER } from './serverGroup/writer/serverGroup.write.service';
+import './pipeline/stages/destroyAsg/appengineDestroyAsgStage';
+import './pipeline/stages/disableAsg/appengineDisableAsgStage';
+import './pipeline/stages/editLoadBalancer/appengineEditLoadBalancerStage';
+import './pipeline/stages/enableAsg/appengineEnableAsgStage';
+import './pipeline/stages/shrinkCluster/appengineShrinkClusterStage';
+import './pipeline/stages/startServerGroup/appengineStartServerGroupStage';
+import './pipeline/stages/stopServerGroup/appengineStopServerGroupStage';
+import { AppengineServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { AppengineCloneServerGroupModal } from './serverGroup/configure/wizard/AppengineCloneServerGroupModal';
+import {
+  AppengineServerGroupActions,
+  appengineServerGroupDetailsGetter,
+  AppengineServerGroupDetailsSection,
+} from './serverGroup/details';
+import { AppengineServerGroupTransformer } from './serverGroup/transformer';
 import './validation/ApplicationNameValidator';
 
 import './logo/appengine.logo.less';
 
-export const APPENGINE_MODULE = 'spinnaker.appengine';
-
-module(APPENGINE_MODULE, [
-  APPENGINE_CLONE_SERVER_GROUP_CTRL,
-  APPENGINE_COMPONENT_URL_DETAILS,
-  APPENGINE_CONDITIONAL_DESCRIPTION_LIST_ITEM,
-  APPENGINE_INSTANCE_DETAILS_CTRL,
-  APPENGINE_LOAD_BALANCER_CREATE_MESSAGE,
-  APPENGINE_LOAD_BALANCER_MODULE,
-  APPENGINE_PIPELINE_MODULE,
-  APPENGINE_SERVER_GROUP_BASIC_SETTINGS_CTRL,
-  APPENGINE_SERVER_GROUP_COMMAND_BUILDER,
-  APPENGINE_SERVER_GROUP_DETAILS_CTRL,
-  APPENGINE_SERVER_GROUP_TRANSFORMER,
-  APPENGINE_SERVER_GROUP_WRITER,
-  CONFIG_FILE_ARTIFACT_LIST,
-]).config(() => {
-  CloudProviderRegistry.registerProvider('appengine', {
-    name: 'App Engine',
-    instance: {
-      detailsTemplateUrl: require('./instance/details/details.html'),
-      detailsController: 'appengineInstanceDetailsCtrl',
-    },
-    serverGroup: {
-      transformer: 'appengineServerGroupTransformer',
-      detailsController: 'appengineServerGroupDetailsCtrl',
-      detailsTemplateUrl: require('./serverGroup/details/details.html'),
-      commandBuilder: 'appengineServerGroupCommandBuilder',
-      cloneServerGroupController: 'appengineCloneServerGroupCtrl',
-      cloneServerGroupTemplateUrl: require('./serverGroup/configure/wizard/serverGroupWizard.html'),
-      skipUpstreamStageCheck: true,
-    },
-    loadBalancer: {
-      transformer: 'appengineLoadBalancerTransformer',
-      createLoadBalancerTemplateUrl: require('./loadBalancer/configure/wizard/wizard.html'),
-      createLoadBalancerController: 'appengineLoadBalancerWizardCtrl',
-      detailsTemplateUrl: require('./loadBalancer/details/details.html'),
-      detailsController: 'appengineLoadBalancerDetailsCtrl',
-    },
-    logo: {
-      path: logo,
-    },
-  });
+CloudProviderRegistry.registerProvider('appengine', {
+  name: 'App Engine',
+  instance: {
+    details: AppengineInstanceDetails,
+  },
+  serverGroup: {
+    transformer: AppengineServerGroupTransformer,
+    commandBuilder: AppengineServerGroupCommandBuilder,
+    detailsActions: AppengineServerGroupActions,
+    detailsGetter: appengineServerGroupDetailsGetter,
+    detailsSections: [AppengineServerGroupDetailsSection],
+    CloneServerGroupModal: AppengineCloneServerGroupModal,
+    skipUpstreamStageCheck: true,
+  },
+  loadBalancer: {
+    transformer: AppengineLoadBalancerTransformer,
+    useDetailsHook: useAppengineLoadBalancerDetails,
+    detailsActions: AppengineLoadBalancerActions,
+    detailsSections: [AppengineLoadBalancerDetailsSection],
+    CreateLoadBalancerModal: AppengineCreateLoadBalancerModal,
+  },
+  logo: {
+    path: logo,
+  },
 });
 
 DeploymentStrategyRegistry.registerProvider('appengine', ['custom']);