@sfdxy/anypoint-connect 0.8.1 → 0.9.1

package/dist/mcp/tools/applications.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
-import { mcpError } from './shared.js';
+import { mcpError, mcpText, dryRunPreview } from './shared.js';
+import { buildCreatePayload, mergeApplicationProperties, mergeForArtifactUpdate, resolveRollbackTarget, } from '../../safety/deployment.js';
+import { errorMessage } from '../../utils/errors.js';
 export function registerApplicationTools(server, client) {
     server.registerTool('list_apps', {
         title: 'List Applications',
@@ -14,7 +16,7 @@ export function registerApplicationTools(server, client) {
         try {
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const deployments = await client.cloudHub2.getDeployments(orgId, env.id);
+            const deployments = await client.cloudHub2.getDetailedDeployments(orgId, env.id);
             return {
                 content: [
                     {
@@ -25,7 +27,7 @@ export function registerApplicationTools(server, client) {
                             version: d.application?.ref?.version,
                             runtime: d.target?.deploymentSettings?.runtime?.version,
                             vCores: d.application?.vCores,
-                            replicas: d.target?.replicas?.length,
+                            replicas: d.target?.replicas,
                             id: d.id,
                         })), null, 2),
                     },
@@ -48,7 +50,7 @@ export function registerApplicationTools(server, client) {
         try {
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const deployment = await client.cloudHub2.findByName(orgId, env.id, appName);
+            const deployment = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
             if (!deployment) {
                 return {
                     content: [{ type: 'text', text: `Application "${appName}" not found in ${env.name}` }],
@@ -74,13 +76,15 @@ export function registerApplicationTools(server, client) {
                             jvm: deployment.target?.deploymentSettings?.jvm,
                             clustered: deployment.target?.deploymentSettings?.clustered,
                             updateStrategy: deployment.target?.deploymentSettings?.updateStrategy,
-                            replicas: deployment.target?.replicas?.map((r) => ({
+                            replicas: deployment.replicas?.map((r) => ({
                                 id: r.id,
                                 state: r.state,
                                 location: r.deploymentLocation,
                             })),
                             publicUrl: deployment.target?.deploymentSettings?.http?.inbound?.publicUrl,
-                            updatedAt: deployment.updatedAt,
+                            updatedAt: deployment.lastModifiedDate
+                                ? new Date(deployment.lastModifiedDate).toISOString()
+                                : undefined,
                         }, null, 2),
                     },
                 ],
@@ -90,6 +94,62 @@ export function registerApplicationTools(server, client) {
             return mcpError(error);
         }
     });
+    server.registerTool('get_deployment_spec', {
+        title: 'Get Deployment Spec',
+        description: 'Returns the full current deployment spec for a CloudHub 2.0 application — the "look before you leap" view used before a redeploy or rollback. Includes the exact artifact reference (groupId:artifactId:version:packaging), Mule runtime version, deployment target (a private space ID vs a shared cloudhub-* region), vCores, replica count with per-replica state and location, update strategy, clustering, JVM args, public URL, desired vs last-successful version, and timestamps. Unlike get_app_status this always fetches full deployment detail. Use it to confirm exactly what is running before changing an artifact, and to capture the current ref so you can roll back.',
+        inputSchema: {
+            appName: z.string().describe('Application name exactly as deployed (case-insensitive match)'),
+            environment: z.string().describe('Environment name (e.g. "Production") or environment ID'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ appName, environment }) => {
+        try {
+            const orgId = await client.getDefaultOrgId();
+            const env = await client.accessManagement.resolveEnvironment(orgId, environment);
+            const d = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            if (!d) {
+                return mcpText(`Application "${appName}" not found in ${env.name}`);
+            }
+            const settings = d.target?.deploymentSettings;
+            const targetId = d.target?.targetId || '';
+            const isPrivateSpace = !targetId.startsWith('cloudhub-');
+            return mcpText({
+                name: d.name,
+                deploymentId: d.id,
+                status: d.status,
+                ref: d.application?.ref,
+                runtime: settings?.runtime?.version,
+                target: {
+                    provider: d.target?.provider,
+                    targetId,
+                    kind: isPrivateSpace ? 'private-space' : 'shared-region',
+                },
+                vCores: d.application?.vCores,
+                resources: settings?.resources,
+                replicas: {
+                    count: d.target?.replicas ?? 0,
+                    states: d.replicas?.map((r) => ({
+                        id: r.id,
+                        state: r.state,
+                        location: r.deploymentLocation,
+                        version: r.currentDeploymentVersion,
+                    })),
+                },
+                updateStrategy: settings?.updateStrategy,
+                clustered: settings?.clustered,
+                autoscaling: settings?.autoscaling,
+                jvm: settings?.jvm,
+                publicUrl: settings?.http?.inbound?.publicUrl,
+                desiredVersion: d.desiredVersion,
+                lastSuccessfulVersion: d.lastSuccessfulVersion,
+                createdAt: d.creationDate ? new Date(d.creationDate).toISOString() : undefined,
+                updatedAt: d.lastModifiedDate ? new Date(d.lastModifiedDate).toISOString() : undefined,
+            });
+        }
+        catch (error) {
+            return mcpError(error);
+        }
+    });
     server.registerTool('get_app_resources', {
         title: 'Get Application Resources',
         description: 'Returns resource allocation for all apps in an environment: CPU/memory limits and reservations, vCores, replica count, autoscaling config, and JVM args. Use this to identify over-provisioned or under-provisioned applications, compare resource distribution, and optimize costs.',
@@ -101,14 +161,14 @@ export function registerApplicationTools(server, client) {
         try {
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const deployments = await client.cloudHub2.getDeployments(orgId, env.id);
+            const deployments = await client.cloudHub2.getDetailedDeployments(orgId, env.id);
             const resources = deployments.map((d) => ({
                 name: d.name,
                 status: d.status,
                 vCores: d.application?.vCores,
                 cpu: d.target?.deploymentSettings?.resources?.cpu,
                 memory: d.target?.deploymentSettings?.resources?.memory,
-                replicas: d.target?.replicas?.length ?? 0,
+                replicas: d.target?.replicas ?? 0,
                 autoscaling: d.target?.deploymentSettings?.autoscaling,
                 jvm: d.target?.deploymentSettings?.jvm,
                 clustered: d.target?.deploymentSettings?.clustered,
@@ -142,13 +202,12 @@ export function registerApplicationTools(server, client) {
         try {
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const deployment = await client.cloudHub2.findByName(orgId, env.id, appName);
-            if (!deployment) {
+            const detail = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            if (!detail) {
                 return {
                     content: [{ type: 'text', text: `Application "${appName}" not found in ${env.name}` }],
                 };
             }
-            const detail = await client.cloudHub2.getDeployment(orgId, env.id, deployment.id);
             const config = (detail.application?.configuration ?? {});
             const propertiesService = config['mule.agent.application.properties.service'];
             const properties = (propertiesService?.properties ?? {});
@@ -272,81 +331,243 @@ export function registerApplicationTools(server, client) {
                 .optional()
                 .describe('Secure (encrypted) application properties as key-value pairs'),
             jvmArgs: z.string().optional().describe('JVM arguments (e.g. "-XX:MaxMetaspaceSize=256m")'),
+            confirm: z
+                .boolean()
+                .optional()
+                .describe('Set true to apply. When omitted/false, returns a dry-run preview and changes nothing.'),
         },
-        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
-    }, async ({ appName, environment, groupId, artifactId, version, runtime, replicas, region, vcores, properties, secureProperties, jvmArgs, }) => {
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
+    }, async ({ appName, environment, groupId, artifactId, version, runtime, replicas, region, vcores, properties, secureProperties, jvmArgs, confirm, }) => {
         try {
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const existing = await client.cloudHub2.findByName(orgId, env.id, appName);
-            const targetRegion = region || 'cloudhub-us-east-2';
-            // Build configuration if properties are provided
-            const configuration = {};
-            if (properties || secureProperties) {
-                configuration['mule.agent.application.properties.service'] = {
-                    applicationName: appName,
-                    ...(properties ? { properties } : {}),
-                    ...(secureProperties ? { secureProperties } : {}),
-                };
-            }
-            const payload = {
-                name: appName,
-                application: {
-                    ref: {
-                        groupId,
-                        artifactId,
-                        version,
-                        packaging: 'jar',
-                    },
-                    desiredState: 'STARTED',
-                    ...(Object.keys(configuration).length > 0 ? { configuration } : {}),
-                },
-                target: {
-                    provider: 'MC',
-                    targetId: targetRegion,
-                    deploymentSettings: {
-                        runtime: { version: runtime || '4.8.0' },
-                        http: {
-                            inbound: {
-                                publicUrl: `${appName}.${targetRegion.replace('cloudhub-', '').replace(/-/g, '')}.cloudhub.io`,
-                            },
+            const existing = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            // ── Update path: existing app → SAFE artifact-ref-only redeploy ──
+            // Infra params (runtime/region/vcores/replicas/jvmArgs) are intentionally NOT
+            // restated here; doing so previously clobbered the live deployment. They are
+            // ignored on redeploy and the caller is told so.
+            if (existing) {
+                const ignored = [
+                    runtime && 'runtime',
+                    region && 'region',
+                    vcores && 'vcores',
+                    replicas && 'replicas',
+                    jvmArgs && 'jvmArgs',
+                    properties && 'properties',
+                    secureProperties && 'secureProperties',
+                ].filter(Boolean);
+                const merged = mergeForArtifactUpdate(existing, { groupId, artifactId, version });
+                const currentVersion = existing.application?.ref?.version || null;
+                if (!confirm) {
+                    return dryRunPreview({
+                        action: 'redeploy (artifact ref only)',
+                        app: appName,
+                        environment: env.name,
+                        current: {
+                            version: currentVersion,
+                            runtime: existing.target?.deploymentSettings?.runtime?.version,
+                            targetId: existing.target?.targetId,
+                            replicas: existing.target?.replicas,
                         },
-                        clustered: false,
-                        enforceDeployingReplicasAcrossNodes: false,
-                        updateStrategy: 'rolling',
-                        ...(jvmArgs ? { jvm: { args: jvmArgs } } : {}),
+                        next: { ref: merged.application.ref },
+                        preserved: 'runtime, target/space, replicas, resources, settings',
+                        ...(ignored.length
+                            ? {
+                                note: `Ignored on redeploy (use update_app_settings / a fresh deploy to change infra): ${ignored.join(', ')}`,
+                            }
+                            : {}),
+                    });
+                }
+                const deployment = await client.cloudHub2.updateArtifactRef(orgId, env.id, existing.id, merged.application.ref);
+                return mcpText({
+                    message: `✅ Redeployed "${appName}" in ${env.name} (artifact ref only)`,
+                    deploymentId: deployment.id,
+                    status: deployment.status,
+                    version: `${groupId}:${artifactId}:${version}`,
+                    previousVersion: currentVersion,
+                    preserved: 'runtime, target/space, replicas, resources, settings',
+                    ...(ignored.length ? { ignored } : {}),
+                    tip: 'Use get_app_status to monitor deployment progress.',
+                });
+            }
+            // ── Create path: new app → full payload from the shared builder ──
+            const payload = buildCreatePayload({
+                appName,
+                groupId,
+                artifactId,
+                version,
+                runtime,
+                replicas,
+                region,
+                vcores,
+                properties,
+                secureProperties,
+                jvmArgs,
+            });
+            if (!confirm) {
+                return dryRunPreview({
+                    action: 'create new deployment',
+                    app: appName,
+                    environment: env.name,
+                    next: {
+                        version: `${groupId}:${artifactId}:${version}`,
+                        runtime: payload.target.deploymentSettings.runtime.version,
+                        region: payload.target.targetId,
+                        vCores: payload.application.vCores,
+                        replicas: payload.target.replicas,
                     },
-                    replicas: replicas || 1,
-                },
-            };
-            let deployment;
-            let action;
-            if (existing) {
-                deployment = await client.cloudHub2.updateDeployment(orgId, env.id, existing.id, payload);
-                action = 'Redeployed';
+                });
             }
-            else {
-                deployment = await client.cloudHub2.createDeployment(orgId, env.id, payload);
-                action = 'Created new deployment';
+            const deployment = await client.cloudHub2.createDeployment(orgId, env.id, payload);
+            return mcpText({
+                message: `✅ Created new deployment for "${appName}" in ${env.name}`,
+                deploymentId: deployment.id,
+                status: deployment.status,
+                version: `${groupId}:${artifactId}:${version}`,
+                runtime: payload.target.deploymentSettings.runtime.version,
+                vCores: payload.application.vCores,
+                replicas: payload.target.replicas,
+                region: payload.target.targetId,
+                tip: 'Use get_app_status to monitor deployment progress.',
+            });
+        }
+        catch (error) {
+            return mcpError(error);
+        }
+    });
+    server.registerTool('update_app_artifact', {
+        title: 'Update Application Artifact (Safe Redeploy)',
+        description: 'Safely redeploys an existing CloudHub 2.0 application to a new artifact version by PATCHing ONLY the application reference. The live Mule runtime, deployment target/space, replica count, resources, and settings are all preserved — this is the correct tool for a production version bump, and is preferred over deploy_app for existing apps. Optionally waits for the deployment to reach a running state. Pass confirm:true to apply; without it you get a dry-run preview of the ref change.',
+        inputSchema: {
+            appName: z.string().describe('Application name exactly as deployed (case-insensitive match)'),
+            environment: z.string().describe('Environment name (e.g. "Production") or environment ID'),
+            version: z.string().describe('New artifact version to deploy (e.g. "1.4.12")'),
+            artifactId: z.string().optional().describe('Maven artifact ID. Default: keep the existing one.'),
+            groupId: z.string().optional().describe('Maven group ID. Default: keep the existing one.'),
+            packaging: z
+                .string()
+                .optional()
+                .describe('Artifact packaging. Default: keep existing (usually "jar").'),
+            wait: z
+                .boolean()
+                .optional()
+                .describe('Wait for the redeploy to reach a running state before returning (default: false).'),
+            confirm: z
+                .boolean()
+                .optional()
+                .describe('Set true to apply. When omitted/false, returns a dry-run preview and changes nothing.'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
+    }, async ({ appName, environment, version, artifactId, groupId, packaging, wait, confirm }) => {
+        try {
+            const orgId = await client.getDefaultOrgId();
+            const env = await client.accessManagement.resolveEnvironment(orgId, environment);
+            const existing = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            if (!existing) {
+                return mcpText(`Application "${appName}" not found in ${env.name}. Use deploy_app to create a new deployment.`);
             }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            message: `✅ ${action} for "${appName}" in ${env.name}`,
-                            deploymentId: deployment.id,
-                            status: deployment.status,
-                            version: `${groupId}:${artifactId}:${version}`,
-                            runtime: runtime || '4.8.0',
-                            replicas: replicas || 1,
-                            region: targetRegion,
-                            previousVersion: existing?.application?.ref?.version || null,
-                            tip: 'Use get_app_status to monitor deployment progress.',
-                        }, null, 2),
-                    },
-                ],
-            };
+            const merged = mergeForArtifactUpdate(existing, { groupId, artifactId, version, packaging });
+            const oldRef = existing.application?.ref;
+            if (!confirm) {
+                return dryRunPreview({
+                    action: 'update artifact ref (safe redeploy)',
+                    app: appName,
+                    environment: env.name,
+                    current: { ref: oldRef },
+                    next: { ref: merged.application.ref },
+                    preserved: 'runtime, target/space, replicas, resources, settings',
+                });
+            }
+            let deployment = await client.cloudHub2.updateArtifactRef(orgId, env.id, existing.id, merged.application.ref);
+            let waitResult;
+            if (wait) {
+                try {
+                    deployment = await client.cloudHub2.waitForDeployment(orgId, env.id, deployment.id);
+                    waitResult = deployment.status;
+                }
+                catch (waitErr) {
+                    waitResult = `did not settle: ${errorMessage(waitErr)}`;
+                }
+            }
+            return mcpText({
+                message: `✅ Updated "${appName}" in ${env.name} to v${version}`,
+                deploymentId: deployment.id,
+                status: deployment.status,
+                from: oldRef,
+                to: merged.application.ref,
+                preserved: 'runtime, target/space, replicas, resources, settings',
+                ...(wait ? { waitResult } : { tip: 'Pass wait:true or use get_app_status to monitor progress.' }),
+            });
+        }
+        catch (error) {
+            return mcpError(error);
+        }
+    });
+    server.registerTool('rollback_app', {
+        title: 'Roll Back Application',
+        description: 'Rolls an existing CloudHub 2.0 application back to a previous artifact by PATCHing only the application reference (runtime, target, replicas, and settings are preserved). By default it resolves the last successful or newest distinct historical artifact ref; pass toVersion to select a specific artifact version. Pass confirm:true to apply; without it you get a dry-run preview.',
+        inputSchema: {
+            appName: z.string().describe('Application name exactly as deployed (case-insensitive match)'),
+            environment: z.string().describe('Environment name (e.g. "Production") or environment ID'),
+            toVersion: z
+                .string()
+                .optional()
+                .describe('Artifact version to roll back to. Default: newest distinct historical artifact.'),
+            wait: z
+                .boolean()
+                .optional()
+                .describe('Wait for the rollback to reach a running state (default: false).'),
+            confirm: z
+                .boolean()
+                .optional()
+                .describe('Set true to apply. When omitted/false, returns a dry-run preview and changes nothing.'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
+    }, async ({ appName, environment, toVersion, wait, confirm }) => {
+        try {
+            const orgId = await client.getDefaultOrgId();
+            const env = await client.accessManagement.resolveEnvironment(orgId, environment);
+            const existing = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            if (!existing) {
+                return mcpText(`Application "${appName}" not found in ${env.name}`);
+            }
+            const specs = await client.cloudHub2.getDeploymentSpecs(orgId, env.id, existing.id);
+            const target = resolveRollbackTarget(existing, specs, toVersion);
+            if (!target) {
+                return mcpText(`No distinct rollback target for "${appName}" in ${env.name}. ` +
+                    'Pass toVersion to select a specific artifact version.');
+            }
+            if (!confirm) {
+                return dryRunPreview({
+                    action: 'rollback (artifact ref only)',
+                    app: appName,
+                    environment: env.name,
+                    current: { ref: existing.application.ref, specId: existing.desiredVersion },
+                    next: { ref: target.ref, sourceSpecId: target.sourceSpecId },
+                    preserved: 'runtime, target/space, replicas, resources, settings',
+                });
+            }
+            let deployment = await client.cloudHub2.rollbackToRef(orgId, env.id, existing.id, target.ref);
+            let waitResult;
+            if (wait) {
+                try {
+                    deployment = await client.cloudHub2.waitForDeployment(orgId, env.id, deployment.id);
+                    waitResult = deployment.status;
+                }
+                catch (waitErr) {
+                    waitResult = `did not settle: ${errorMessage(waitErr)}`;
+                }
+            }
+            return mcpText({
+                message: `✅ Rolled back "${appName}" in ${env.name}: ${existing.application.ref.version} → ${target.ref.version}`,
+                deploymentId: deployment.id,
+                status: deployment.status,
+                rolledBackFrom: existing.application.ref,
+                rolledBackTo: target.ref,
+                sourceSpecId: target.sourceSpecId,
+                preserved: 'runtime, target/space, replicas, resources, settings',
+                ...(wait ? { waitResult } : {}),
+            });
         }
         catch (error) {
             return mcpError(error);
@@ -370,7 +591,7 @@ export function registerApplicationTools(server, client) {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
     }, async ({ appName, environment, properties, secureProperties }) => {
         try {
-            if (!properties && !secureProperties) {
+            if (Object.keys(properties ?? {}).length + Object.keys(secureProperties ?? {}).length === 0) {
                 return {
                     content: [
                         {
@@ -383,44 +604,15 @@ export function registerApplicationTools(server, client) {
             }
             const orgId = await client.getDefaultOrgId();
             const env = await client.accessManagement.resolveEnvironment(orgId, environment);
-            const deployment = await client.cloudHub2.findByName(orgId, env.id, appName);
-            if (!deployment) {
+            const detail = await client.cloudHub2.findDetailByName(orgId, env.id, appName);
+            if (!detail) {
                 return {
                     content: [{ type: 'text', text: `Application "${appName}" not found in ${env.name}` }],
                     isError: true,
                 };
             }
-            // Fetch current deployment details to merge properties
-            const detail = await client.cloudHub2.getDeployment(orgId, env.id, deployment.id);
-            const existingConfig = (detail.application?.configuration ?? {});
-            const existingService = (existingConfig['mule.agent.application.properties.service'] ?? {});
-            const existingProps = (existingService.properties ?? {});
-            const existingSecure = (existingService.secureProperties ?? {});
-            const mergedProps = { ...existingProps, ...(properties || {}) };
-            const mergedSecure = { ...existingSecure, ...(secureProperties || {}) };
-            const runtimeVersion = deployment.target.deploymentSettings?.runtime?.version || '4.8.0';
-            await client.cloudHub2.updateDeployment(orgId, env.id, deployment.id, {
-                name: deployment.name,
-                application: {
-                    ref: deployment.application.ref,
-                    desiredState: 'STARTED',
-                    configuration: {
-                        'mule.agent.application.properties.service': {
-                            applicationName: deployment.name,
-                            properties: mergedProps,
-                            secureProperties: mergedSecure,
-                        },
-                    },
-                },
-                target: {
-                    provider: 'MC',
-                    targetId: deployment.target.targetId,
-                    deploymentSettings: {
-                        ...deployment.target.deploymentSettings,
-                        runtime: { version: runtimeVersion },
-                    },
-                },
-            });
+            const merged = mergeApplicationProperties(detail, properties, secureProperties);
+            await client.cloudHub2.updateApplicationConfiguration(orgId, env.id, detail.id, merged);
             return {
                 content: [
                     {
@@ -458,22 +650,7 @@ export function registerApplicationTools(server, client) {
                     isError: true,
                 };
             }
-            const runtimeVersion = deployment.target.deploymentSettings?.runtime?.version || '4.8.0';
-            await client.cloudHub2.updateDeployment(orgId, env.id, deployment.id, {
-                name: deployment.name,
-                application: {
-                    ref: deployment.application.ref,
-                    desiredState: 'STOPPED',
-                },
-                target: {
-                    provider: 'MC',
-                    targetId: deployment.target.targetId,
-                    deploymentSettings: {
-                        ...deployment.target.deploymentSettings,
-                        runtime: { version: runtimeVersion },
-                    },
-                },
-            });
+            await client.cloudHub2.setDesiredState(orgId, env.id, deployment.id, 'STOPPED');
             return {
                 content: [
                     {
@@ -506,22 +683,7 @@ export function registerApplicationTools(server, client) {
                     isError: true,
                 };
             }
-            const runtimeVersion = deployment.target.deploymentSettings?.runtime?.version || '4.8.0';
-            await client.cloudHub2.updateDeployment(orgId, env.id, deployment.id, {
-                name: deployment.name,
-                application: {
-                    ref: deployment.application.ref,
-                    desiredState: 'STARTED',
-                },
-                target: {
-                    provider: 'MC',
-                    targetId: deployment.target.targetId,
-                    deploymentSettings: {
-                        ...deployment.target.deploymentSettings,
-                        runtime: { version: runtimeVersion },
-                    },
-                },
-            });
+            await client.cloudHub2.setDesiredState(orgId, env.id, deployment.id, 'STARTED');
             return {
                 content: [
                     {