@capawesome/cli 4.17.2 → 4.18.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [4.18.0](https://github.com/capawesome-team/cli/compare/v4.17.3...v4.18.0) (2026-08-02)
+
+
+### Features
+
+* **apps:** add `apps:builds:run` command ([#198](https://github.com/capawesome-team/cli/issues/198)) ([a3926fd](https://github.com/capawesome-team/cli/commit/a3926fd1514f2534f9132fccb1e9d7f7eb75565c))
+* **apps:** add apps:automations commands ([#199](https://github.com/capawesome-team/cli/issues/199)) ([6e95719](https://github.com/capawesome-team/cli/commit/6e9571914754df2ba64c61e2d2172f2b2031785c))
+* **apps:** add commands to manage native configurations ([#196](https://github.com/capawesome-team/cli/issues/196)) ([5a3480e](https://github.com/capawesome-team/cli/commit/5a3480e094e16a72ada5baac1ff1cbc8ffbfd512))
+
+## [4.17.3](https://github.com/capawesome-team/cli/compare/v4.17.2...v4.17.3) (2026-07-21)
+
+
+### Bug Fixes
+
+* **deps:** update `brace-expansion` to `5.0.7` ([1757368](https://github.com/capawesome-team/cli/commit/1757368e7eb796a0cc9a6975e460e340f51fd48a))
+
 ## [4.17.2](https://github.com/capawesome-team/cli/compare/v4.17.1...v4.17.2) (2026-07-18)
 
 

package/dist/commands/apps/automations/create.js

@@ -0,0 +1,141 @@
+import appAutomationsService from '../../../services/app-automations.js';
+import appsService from '../../../services/apps.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new app automation.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        certificate: z.string().optional().describe('The name of the certificate to use for the build.'),
+        channel: z.string().optional().describe('The name of the channel to deploy to (Web only).'),
+        commitMessagePattern: z
+            .string()
+            .optional()
+            .describe('Only trigger for commits whose message matches this pattern (branch triggers only).'),
+        configuration: z.string().optional().describe('The name of the native configuration (Android/iOS only).'),
+        destination: z.string().optional().describe('The name of the destination to deploy to (Android/iOS only).'),
+        environment: z.string().optional().describe('The name of the environment to use for the build.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        name: z.string().optional().describe('Name of the automation.'),
+        platform: z
+            .enum(['android', 'ios', 'web'], {
+            message: 'Platform must be either `android`, `ios`, or `web`.',
+        })
+            .optional()
+            .describe('The platform for the build. Supported values are `android`, `ios`, and `web`.'),
+        stack: z
+            .enum(['macos-sequoia', 'macos-tahoe'], {
+            message: 'Build stack must be either `macos-sequoia` or `macos-tahoe`.',
+        })
+            .optional()
+            .describe('The build stack to use for the build process.'),
+        triggerPattern: z
+            .string()
+            .optional()
+            .describe('Only trigger for branches or tags matching this pattern. Defaults to all.'),
+        triggerType: z
+            .enum(['branch', 'tag'], {
+            message: 'Trigger type must be either `branch` or `tag`.',
+        })
+            .optional()
+            .describe('What triggers the automation. Supported values are `branch` and `tag`.'),
+        type: z
+            .enum(['app-store', 'ad-hoc', 'debug', 'development', 'release', 'simulator'], {
+            message: 'Build type must be one of `app-store`, `ad-hoc`, `debug`, `development`, `release`, or `simulator`.',
+        })
+            .optional()
+            .describe('The type of build to create.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, json, name, platform, triggerType } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!name) {
+            if (!isInteractive()) {
+                consola.error('You must provide the automation name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            name = await prompt('Enter the name of the automation:', { type: 'text' });
+            if (!name) {
+                consola.error('You must provide an automation name.');
+                process.exit(1);
+            }
+        }
+        if (!triggerType) {
+            if (!isInteractive()) {
+                consola.error('You must provide the trigger type when running in non-interactive environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            triggerType = await prompt('Select what triggers the automation:', {
+                type: 'select',
+                options: [
+                    { label: 'Branch', value: 'branch' },
+                    { label: 'Tag', value: 'tag' },
+                ],
+            });
+            if (!triggerType) {
+                consola.error('You must select a trigger type.');
+                process.exit(1);
+            }
+        }
+        // Derive platform from app type for single-platform apps
+        if (!platform) {
+            const app = await appsService.findOne({ appId });
+            if (app.type === 'android' || app.type === 'ios') {
+                platform = app.type;
+            }
+        }
+        if (!platform) {
+            if (!isInteractive()) {
+                consola.error('You must provide a platform when running in non-interactive environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            platform = await prompt('Select the platform for the build:', {
+                type: 'select',
+                options: [
+                    { label: 'Android', value: 'android' },
+                    { label: 'iOS', value: 'ios' },
+                    { label: 'Web', value: 'web' },
+                ],
+            });
+            if (!platform) {
+                consola.error('You must select a platform.');
+                process.exit(1);
+            }
+        }
+        const automation = await appAutomationsService.create({
+            appCertificateName: options.certificate,
+            appChannelName: options.channel,
+            appConfigurationName: options.configuration,
+            appDestinationName: options.destination,
+            appEnvironmentName: options.environment,
+            appId,
+            buildStack: options.stack,
+            buildType: options.type,
+            commitMessagePattern: options.commitMessagePattern,
+            name,
+            platform,
+            triggerPattern: options.triggerPattern,
+            triggerType,
+        });
+        if (json) {
+            console.log(JSON.stringify({ id: automation.id }, null, 2));
+        }
+        else {
+            consola.info(`Automation ID: ${automation.id}`);
+            consola.success('Automation created successfully.');
+        }
+    }),
+});

package/dist/commands/apps/automations/create.test.js

@@ -0,0 +1,162 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.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 createAutomationCommand from './create.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => true,
+}));
+describe('apps-automations-create', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    const mockPromptOrganizationSelection = vi.mocked(promptOrganizationSelection);
+    const mockPromptAppSelection = vi.mocked(promptAppSelection);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should create automation with provided options', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = {
+            appId,
+            certificate: 'Release Keystore',
+            configuration: 'Production',
+            environment: 'Staging',
+            name: 'nightly',
+            platform: 'android',
+            stack: 'macos-tahoe',
+            triggerPattern: 'main',
+            triggerType: 'branch',
+            type: 'release',
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/automations`, {
+            appCertificateName: 'Release Keystore',
+            appConfigurationName: 'Production',
+            appEnvironmentName: 'Staging',
+            buildStack: 'macos-tahoe',
+            buildType: 'release',
+            name: 'nightly',
+            platform: 'android',
+            triggerPattern: 'main',
+            triggerType: 'branch',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(201, { id: automationId, name: 'nightly' });
+        await createAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Automation ID: ${automationId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation created successfully.');
+    });
+    it('should output JSON when json flag is set', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = {
+            appId,
+            json: true,
+            name: 'nightly',
+            platform: 'web',
+            triggerType: 'tag',
+        };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/automations`, {
+            name: 'nightly',
+            platform: 'web',
+            triggerType: 'tag',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(201, { id: automationId, name: 'nightly' });
+        await createAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: automationId }, null, 2));
+        expect(mockConsola.info).not.toHaveBeenCalled();
+    });
+    it('should prompt for app, name and trigger type when not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const automationId = 'automation-456';
+        const options = { platform: 'ios' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/automations`, {
+            name: 'releases',
+            platform: 'ios',
+            triggerType: 'tag',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(201, { id: automationId, name: 'releases' });
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt
+            .mockResolvedValueOnce('releases') // name
+            .mockResolvedValueOnce('tag'); // trigger type
+        await createAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Enter the name of the automation:', { type: 'text' });
+        expect(mockPrompt).toHaveBeenCalledWith('Select what triggers the automation:', {
+            type: 'select',
+            options: [
+                { label: 'Branch', value: 'branch' },
+                { label: 'Tag', value: 'tag' },
+            ],
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation created successfully.');
+    });
+    it('should derive the platform from the app type when not provided', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, name: 'nightly', triggerType: 'branch' };
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, { id: appId, type: 'android' });
+        const createScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/automations`, {
+            name: 'nightly',
+            platform: 'android',
+            triggerType: 'branch',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(201, { id: automationId, name: 'nightly' });
+        await createAutomationCommand.action(options, undefined);
+        expect(appScope.isDone()).toBe(true);
+        expect(createScope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation created successfully.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const options = {
+            appId,
+            name: 'nightly',
+            platform: 'android',
+            triggerType: 'branch',
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/automations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(400, { message: 'Automation with this name already exists.' });
+        await expect(createAutomationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/apps/automations/delete.js

@@ -0,0 +1,66 @@
+import appAutomationsService from '../../../services/app-automations.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Delete an app automation.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        automationId: z.string().optional().describe('ID of the automation. Either the ID or name must be provided.'),
+        name: z.string().optional().describe('Name of the automation. Either the ID or name must be provided.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompt.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options, args) => {
+        let { appId, automationId, name } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!automationId && !name) {
+            if (!isInteractive()) {
+                consola.error('You must provide either the automation ID or name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const automations = await appAutomationsService.findAll({ appId });
+            if (!automations.length) {
+                consola.error('No automations found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            automationId = await prompt('Select the automation to delete:', {
+                type: 'select',
+                options: automations.map((automation) => ({ label: automation.name, value: automation.id })),
+            });
+        }
+        if (!automationId && name) {
+            const automations = await appAutomationsService.findAll({ appId, name });
+            const automation = automations[0];
+            if (!automation) {
+                consola.error(`No automation found with name '${name}'.`);
+                process.exit(1);
+            }
+            automationId = automation.id;
+        }
+        if (!automationId) {
+            consola.error('Automation not found.');
+            process.exit(1);
+        }
+        if (!options.yes && isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to delete this automation?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appAutomationsService.delete({ appId, automationId });
+        consola.success('Automation deleted successfully.');
+    }),
+});

package/dist/commands/apps/automations/delete.test.js

@@ -0,0 +1,127 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.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 deleteAutomationCommand from './delete.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => true,
+}));
+describe('apps-automations-delete', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    const mockPromptOrganizationSelection = vi.mocked(promptOrganizationSelection);
+    const mockPromptAppSelection = vi.mocked(promptAppSelection);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should delete automation by ID after confirmation', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, automationId };
+        mockPrompt.mockResolvedValueOnce(true); // confirmation
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        await deleteAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this automation?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation deleted successfully.');
+    });
+    it('should delete automation by name when yes flag is set', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, name: 'nightly', yes: true };
+        const listScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .query({ name: 'nightly' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, [{ id: automationId, appId, name: 'nightly' }]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        await deleteAutomationCommand.action(options, undefined);
+        expect(listScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockPrompt).not.toHaveBeenCalled();
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation deleted successfully.');
+    });
+    it('should exit when no automation matches the name', async () => {
+        const appId = 'app-123';
+        const options = { appId, name: 'missing', yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .query({ name: 'missing' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, []);
+        await expect(deleteAutomationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith("No automation found with name 'missing'.");
+    });
+    it('should not delete automation when confirmation is declined', async () => {
+        const options = { appId: 'app-123', automationId: 'automation-456' };
+        mockPrompt.mockResolvedValueOnce(false); // declined confirmation
+        await deleteAutomationCommand.action(options, undefined);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app and automation when not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const automationId = 'automation-456';
+        const options = {};
+        const listScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, [{ id: automationId, appId, name: 'nightly' }]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt
+            .mockResolvedValueOnce(automationId) // automation selection
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteAutomationCommand.action(options, undefined);
+        expect(listScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Select the automation to delete:', {
+            type: 'select',
+            options: [{ label: 'nightly', value: automationId }],
+        });
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, automationId, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(404, { message: 'Automation not found.' });
+        await expect(deleteAutomationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/automations/get.js

@@ -0,0 +1,62 @@
+import appAutomationsService from '../../../services/app-automations.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Get an existing app automation.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        automationId: z.string().optional().describe('ID of the automation. Either the ID or name must be provided.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        name: z.string().optional().describe('Name of the automation. Either the ID or name must be provided.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, automationId, json, name } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!automationId && !name) {
+            if (!isInteractive()) {
+                consola.error('You must provide either the automation ID or name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const automations = await appAutomationsService.findAll({ appId });
+            if (!automations.length) {
+                consola.error('No automations found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            automationId = await prompt('Select the automation:', {
+                type: 'select',
+                options: automations.map((automation) => ({ label: automation.name, value: automation.id })),
+            });
+        }
+        let automation;
+        if (automationId) {
+            automation = await appAutomationsService.findOneById({ appId, automationId });
+        }
+        else if (name) {
+            const automations = await appAutomationsService.findAll({ appId, name });
+            automation = automations[0];
+        }
+        if (!automation) {
+            consola.error('Automation not found.');
+            process.exit(1);
+        }
+        if (json) {
+            console.log(JSON.stringify(automation, null, 2));
+        }
+        else {
+            console.table(automation);
+            consola.success('Automation retrieved successfully.');
+        }
+    }),
+});