@capawesome/cli 3.10.2 → 4.0.0

package/dist/commands/apps/{bundles/create.test.js → liveupdates/register.test.js}

@@ -1,13 +1,11 @@
 import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
 import authorizationService from '../../../services/authorization-service.js';
-import { findCapacitorConfigPath } from '../../../utils/capacitor-config.js';
-import { fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory } from '../../../utils/file.js';
-import { findPackageJsonPath } from '../../../utils/package-json.js';
+import { fileExistsAtPath } from '../../../utils/file.js';
 import userConfig from '../../../utils/user-config.js';
 import consola from 'consola';
 import nock from 'nock';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import createBundleCommand from './create.js';
+import registerCommand from './register.js';
 // Mock dependencies
 vi.mock('@/utils/user-config.js');
 vi.mock('@/services/authorization-service.js');
@@ -17,25 +15,17 @@ vi.mock('@/utils/buffer.js');
 vi.mock('@/utils/private-key.js');
 vi.mock('@/utils/hash.js');
 vi.mock('@/utils/signature.js');
-vi.mock('@/utils/capacitor-config.js');
-vi.mock('@/utils/package-json.js');
 vi.mock('consola');
-describe('apps-bundles-create', () => {
+describe('apps-liveupdates-register', () => {
     const mockUserConfig = vi.mocked(userConfig);
     const mockAuthorizationService = vi.mocked(authorizationService);
     const mockFileExistsAtPath = vi.mocked(fileExistsAtPath);
-    const mockGetFilesInDirectoryAndSubdirectories = vi.mocked(getFilesInDirectoryAndSubdirectories);
-    const mockIsDirectory = vi.mocked(isDirectory);
-    const mockFindCapacitorConfigPath = vi.mocked(findCapacitorConfigPath);
-    const mockFindPackageJsonPath = vi.mocked(findPackageJsonPath);
     const mockConsola = vi.mocked(consola);
     beforeEach(() => {
         vi.clearAllMocks();
         mockUserConfig.read.mockReturnValue({ token: 'test-token' });
         mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
         mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
-        mockFindCapacitorConfigPath.mockResolvedValue(undefined);
-        mockFindPackageJsonPath.mockResolvedValue(undefined);
         vi.spyOn(process, 'exit').mockImplementation((code) => {
             throw new Error(`Process exited with code ${code}`);
         });
@@ -46,35 +36,23 @@ describe('apps-bundles-create', () => {
     });
     it('should require authentication', async () => {
         const appId = 'app-123';
-        const options = { appId, path: './dist', artifactType: 'zip', rollout: 1 };
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const options = { appId, url: bundleUrl, rolloutPercentage: 1 };
         mockAuthorizationService.hasAuthorizationToken.mockReturnValue(false);
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        await expect(registerCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
         expect(mockConsola.error).toHaveBeenCalledWith('You must be logged in to run this command. Please run the `login` command first.');
     });
-    it('should create bundle with self-hosted URL', async () => {
+    it('should register bundle with self-hosted URL', async () => {
         const appId = 'app-123';
         const bundleUrl = 'https://example.com/bundle.zip';
-        const bundlePath = './bundle.zip';
-        const testHash = 'test-hash';
         const bundleId = 'bundle-456';
         const testToken = 'test-token';
-        const testBuffer = Buffer.from('test');
         const options = {
             appId,
             url: bundleUrl,
-            path: bundlePath,
-            artifactType: 'zip',
-            rollout: 1,
+            rolloutPercentage: 1,
+            yes: true,
         };
-        mockFileExistsAtPath.mockResolvedValue(true);
-        mockIsDirectory.mockResolvedValue(false);
-        // Mock utility functions
-        const mockZip = await import('../../../utils/zip.js');
-        const mockBuffer = await import('../../../utils/buffer.js');
-        const mockHash = await import('../../../utils/hash.js');
-        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
-        vi.mocked(mockBuffer.createBufferFromPath).mockResolvedValue(testBuffer);
-        vi.mocked(mockHash.createHash).mockResolvedValue(testHash);
         const appScope = nock(DEFAULT_API_BASE_URL)
             .get(`/v1/apps/${appId}`)
             .matchHeader('Authorization', `Bearer ${testToken}`)
@@ -83,78 +61,94 @@ describe('apps-bundles-create', () => {
             .post(`/v1/apps/${appId}/bundles`, {
             appId,
             url: bundleUrl,
-            checksum: testHash,
             artifactType: 'zip',
-            rolloutPercentage: 1,
+            rolloutPercentage: 0.01,
         })
             .matchHeader('Authorization', `Bearer ${testToken}`)
-            .reply(201, { id: bundleId });
-        await createBundleCommand.action(options, undefined);
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        await registerCommand.action(options, undefined);
         expect(appScope.isDone()).toBe(true);
         expect(bundleScope.isDone()).toBe(true);
-        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
-        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle ID: ${bundleId}`);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully registered.');
     });
-    it('should handle path validation errors', async () => {
-        const appId = 'app-123';
-        const nonexistentPath = './nonexistent';
-        const options = { appId, path: nonexistentPath, artifactType: 'zip', rollout: 1 };
-        mockFileExistsAtPath.mockResolvedValue(false);
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
-        expect(mockConsola.error).toHaveBeenCalledWith('The path does not exist.');
-    });
-    it('should validate manifest artifact type requires directory', async () => {
-        const appId = 'app-123';
-        const bundlePath = './bundle.zip';
-        const options = {
-            appId,
-            path: bundlePath,
-            artifactType: 'manifest',
-            rollout: 1,
-        };
-        mockFileExistsAtPath.mockResolvedValue(true);
-        mockIsDirectory.mockResolvedValue(false);
-        // Mock zip utility to return true so path validation passes
-        const mockZip = await import('../../../utils/zip.js');
-        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
-        expect(mockConsola.error).toHaveBeenCalledWith('The path must be a folder when creating a bundle with an artifact type of `manifest`.');
-    });
-    it('should validate manifest artifact type cannot use URL', async () => {
+    it('should pass gitRef to API when provided', async () => {
         const appId = 'app-123';
         const bundleUrl = 'https://example.com/bundle.zip';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const gitRef = 'v1.0.0';
         const options = {
             appId,
             url: bundleUrl,
-            artifactType: 'manifest',
-            rollout: 1,
+            rolloutPercentage: 1,
+            gitRef,
+            yes: true,
         };
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
-        expect(mockConsola.error).toHaveBeenCalledWith('It is not yet possible to provide a URL when creating a bundle with an artifact type of `manifest`.');
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            url: bundleUrl,
+            artifactType: 'zip',
+            gitRef,
+            rolloutPercentage: 0.01,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        await registerCommand.action(options, undefined);
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully registered.');
     });
-    it('should handle API error during creation', async () => {
+    it('should register bundle with checksum when path is provided', async () => {
         const appId = 'app-123';
         const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './bundle.zip';
+        const testHash = 'test-hash';
+        const bundleId = 'bundle-456';
         const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
         const options = {
             appId,
             url: bundleUrl,
-            artifactType: 'zip',
-            rollout: 1,
+            path: bundlePath,
+            rolloutPercentage: 1,
+            yes: true,
         };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
+        const mockBuffer = await import('../../../utils/buffer.js');
+        const mockHash = await import('../../../utils/hash.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
+        vi.mocked(mockBuffer.createBufferFromPath).mockResolvedValue(testBuffer);
+        vi.mocked(mockHash.createHash).mockResolvedValue(testHash);
         const appScope = nock(DEFAULT_API_BASE_URL)
             .get(`/v1/apps/${appId}`)
             .matchHeader('Authorization', `Bearer ${testToken}`)
             .reply(200, { id: appId, name: 'Test App' });
         const bundleScope = nock(DEFAULT_API_BASE_URL)
-            .post(`/v1/apps/${appId}/bundles`)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            url: bundleUrl,
+            checksum: testHash,
+            artifactType: 'zip',
+            rolloutPercentage: 0.01,
+        })
             .matchHeader('Authorization', `Bearer ${testToken}`)
-            .reply(400, { message: 'Invalid bundle data' });
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow();
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        await registerCommand.action(options, undefined);
         expect(appScope.isDone()).toBe(true);
         expect(bundleScope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully registered.');
     });
-    it('should handle private key file path', async () => {
+    it('should register bundle with signature when private key is provided', async () => {
         const appId = 'app-123';
         const bundleUrl = 'https://example.com/bundle.zip';
         const bundlePath = './bundle.zip';
@@ -169,8 +163,8 @@ describe('apps-bundles-create', () => {
             url: bundleUrl,
             path: bundlePath,
             privateKey: privateKeyPath,
-            artifactType: 'zip',
-            rollout: 1,
+            rolloutPercentage: 1,
+            yes: true,
         };
         mockFileExistsAtPath.mockImplementation((path) => {
             if (path === privateKeyPath)
@@ -179,7 +173,6 @@ describe('apps-bundles-create', () => {
                 return Promise.resolve(true);
             return Promise.resolve(false);
         });
-        mockIsDirectory.mockResolvedValue(false);
         // Mock utility functions
         const mockZip = await import('../../../utils/zip.js');
         const mockBuffer = await import('../../../utils/buffer.js');
@@ -204,16 +197,17 @@ describe('apps-bundles-create', () => {
             checksum: testHash,
             signature: testSignature,
             artifactType: 'zip',
-            rolloutPercentage: 1,
+            rolloutPercentage: 0.01,
         })
             .matchHeader('Authorization', `Bearer ${testToken}`)
-            .reply(201, { id: bundleId });
-        await createBundleCommand.action(options, undefined);
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        await registerCommand.action(options, undefined);
         expect(appScope.isDone()).toBe(true);
         expect(bundleScope.isDone()).toBe(true);
-        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully registered.');
     });
-    it('should handle private key plain text content', async () => {
+    it('should handle private key with plain text content', async () => {
         const appId = 'app-123';
         const bundleUrl = 'https://example.com/bundle.zip';
         const bundlePath = './bundle.zip';
@@ -228,11 +222,10 @@ describe('apps-bundles-create', () => {
             url: bundleUrl,
             path: bundlePath,
             privateKey: privateKeyContent,
-            artifactType: 'zip',
-            rollout: 1,
+            rolloutPercentage: 1,
+            yes: true,
         };
         mockFileExistsAtPath.mockResolvedValue(true);
-        mockIsDirectory.mockResolvedValue(false);
         // Mock utility functions
         const mockZip = await import('../../../utils/zip.js');
         const mockBuffer = await import('../../../utils/buffer.js');
@@ -257,59 +250,78 @@ describe('apps-bundles-create', () => {
             checksum: testHash,
             signature: testSignature,
             artifactType: 'zip',
-            rolloutPercentage: 1,
+            rolloutPercentage: 0.01,
         })
             .matchHeader('Authorization', `Bearer ${testToken}`)
-            .reply(201, { id: bundleId });
-        await createBundleCommand.action(options, undefined);
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        await registerCommand.action(options, undefined);
         expect(appScope.isDone()).toBe(true);
         expect(bundleScope.isDone()).toBe(true);
-        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully registered.');
     });
     it('should handle private key file not found', async () => {
         const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './bundle.zip';
         const privateKeyPath = 'nonexistent-key.pem';
         const options = {
             appId,
-            path: './dist',
+            url: bundleUrl,
+            path: bundlePath,
             privateKey: privateKeyPath,
-            artifactType: 'zip',
-            rollout: 1,
+            rolloutPercentage: 1,
         };
         mockFileExistsAtPath.mockImplementation((path) => {
             if (path === privateKeyPath)
                 return Promise.resolve(false);
             return Promise.resolve(true);
         });
-        mockIsDirectory.mockResolvedValue(true);
-        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
-            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
-        ]);
         // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
         const mockBuffer = await import('../../../utils/buffer.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
         vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        await expect(registerCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
         expect(mockConsola.error).toHaveBeenCalledWith('Private key file not found.');
     });
-    it('should handle invalid private key format', async () => {
+    it('should validate path must be a zip file', async () => {
         const appId = 'app-123';
-        const invalidPrivateKey = 'not-a-valid-key';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './dist';
         const options = {
             appId,
-            path: './dist',
-            privateKey: invalidPrivateKey,
-            artifactType: 'zip',
-            rollout: 1,
+            url: bundleUrl,
+            path: bundlePath,
+            rolloutPercentage: 1,
         };
         mockFileExistsAtPath.mockResolvedValue(true);
-        mockIsDirectory.mockResolvedValue(false);
-        // Mock zip utility to pass path validation
+        // Mock zip utility to return false
         const mockZip = await import('../../../utils/zip.js');
-        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
-        // Mock utility functions
-        const mockBuffer = await import('../../../utils/buffer.js');
-        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
-        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
-        expect(mockConsola.error).toHaveBeenCalledWith('Private key must be either a path to a .pem file or the private key content as plain text.');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(false);
+        await expect(registerCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The path must be a zip file when providing a URL.');
+    });
+    it('should handle API error during registration', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const testToken = 'test-token';
+        const options = {
+            appId,
+            url: bundleUrl,
+            rolloutPercentage: 1,
+            yes: true,
+        };
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Invalid bundle data' });
+        await expect(registerCommand.action(options, undefined)).rejects.toThrow();
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
     });
 });

package/dist/commands/apps/liveupdates/rollback.js

@@ -0,0 +1,171 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appChannelsService from '../../../services/app-channels.js';
+import appDeploymentsService from '../../../services/app-deployments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { formatTimeAgo } from '../../../utils/time-format.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Rollback the active build in a channel to a previous build.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID of the channel.'),
+        channel: z.string().optional().describe('Name of the channel to rollback.'),
+        steps: z.coerce
+            .number()
+            .int({
+            message: 'Steps must be an integer.',
+        })
+            .min(1, {
+            message: 'Steps must be at least 1.',
+        })
+            .max(5, {
+            message: 'Steps cannot be more than 5.',
+        })
+            .optional()
+            .describe('Number of deployments to go back (1-5).'),
+    })),
+    action: async (options) => {
+        let { appId, channel, steps } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before rolling back a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to rollback a deployment.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to rollback a deployment.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (apps.length === 0) {
+                consola.error('You must create an app before rolling back a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to rollback a deployment for:', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+            if (!appId) {
+                consola.error('You must select an app to rollback a deployment for.');
+                process.exit(1);
+            }
+        }
+        // Prompt for channel name if not provided
+        if (!channel) {
+            if (!isInteractive()) {
+                consola.error('You must provide a channel name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            channel = await prompt('Enter the channel name to rollback:', {
+                type: 'text',
+            });
+            if (!channel) {
+                consola.error('You must enter a channel name to rollback.');
+                process.exit(1);
+            }
+        }
+        // Fetch channel by name
+        const appChannels = await appChannelsService.findAll({ appId, name: channel });
+        if (appChannels.length === 0) {
+            consola.error('Channel not found.');
+            process.exit(1);
+        }
+        const appChannelId = appChannels[0]?.id;
+        // Fetch deployments for the channel
+        const appDeployments = await appDeploymentsService.findAll({
+            appId,
+            appChannelId,
+            limit: 5,
+            relations: 'appBuild',
+        });
+        // Validate that we have at least 2 app deployments (current + previous)
+        if (appDeployments.length < 2) {
+            consola.error('Channel has no previous deployments to rollback to.');
+            process.exit(1);
+        }
+        // Select deployment to rollback to
+        let selectedIndex;
+        if (steps === undefined) {
+            // Interactive selection (exclude index 0 - current deployment)
+            if (!isInteractive()) {
+                consola.error('You must provide --steps when running in non-interactive environment.');
+                process.exit(1);
+            }
+            // Build options for select prompt (skip index 0)
+            const options = appDeployments.slice(1).map((deployment, index) => {
+                const appBuild = appDeployments[index + 1]?.appBuild;
+                if (!appBuild) {
+                    consola.error('Deployment is missing associated build.');
+                    process.exit(1);
+                }
+                const deployedTime = deployment.job?.createdAt ? formatTimeAgo(deployment.job.createdAt) : 'unknown';
+                return {
+                    label: `Build #${appBuild.numberAsString} - Deployed ${deployedTime}`,
+                    value: (index + 1).toString(),
+                };
+            });
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectedValue = await prompt('Which deployment do you want to rollback to:', {
+                type: 'select',
+                options,
+            });
+            if (!selectedValue) {
+                consola.error('You must select a deployment to rollback to.');
+                process.exit(1);
+            }
+            selectedIndex = parseInt(selectedValue, 10);
+        }
+        else {
+            // Validate steps value
+            if (steps >= appDeployments.length) {
+                consola.error(`Cannot rollback ${steps} step${steps === 1 ? '' : 's'}, only ${appDeployments.length - 1} previous deployment${appDeployments.length - 1 === 1 ? '' : 's'} available.`);
+                process.exit(1);
+            }
+            selectedIndex = steps;
+        }
+        // Get the selected deployment and build
+        const selectedAppDeployment = appDeployments[selectedIndex];
+        if (!selectedAppDeployment) {
+            consola.error('Selected deployment not found.');
+            process.exit(1);
+        }
+        // Create new deployment with the selected build
+        consola.start('Creating rollback deployment...');
+        const response = await appDeploymentsService.create({
+            appId,
+            appBuildId: selectedAppDeployment.appBuildId,
+            appChannelName: channel,
+        });
+        consola.info(`Deployment ID: ${response.id}`);
+        consola.info(`Deployment URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/deployments/${response.id}`);
+        consola.success(`Rolled back to Build #${selectedAppDeployment.appBuild?.numberAsString} (${selectedIndex} step${selectedIndex === 1 ? '' : 's'} back).`);
+    },
+});