@capawesome/cli 4.17.2 → 4.18.0

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

@@ -0,0 +1,118 @@
+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 getAutomationCommand from './get.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-get', () => {
+    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 get automation by ID', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const automation = { id: automationId, appId, name: 'nightly' };
+        const options = { appId, automationId };
+        const tableSpy = vi.spyOn(console, 'table').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, automation);
+        await getAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(tableSpy).toHaveBeenCalledWith(automation);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation retrieved successfully.');
+    });
+    it('should get automation by name', async () => {
+        const appId = 'app-123';
+        const automation = { id: 'automation-456', appId, name: 'nightly' };
+        const options = { appId, name: 'nightly' };
+        vi.spyOn(console, 'table').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .query({ name: 'nightly' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, [automation]);
+        await getAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation retrieved successfully.');
+    });
+    it('should output JSON when json flag is set', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const automation = { id: automationId, appId, name: 'nightly' };
+        const options = { appId, automationId, json: true };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, automation);
+        await getAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(logSpy).toHaveBeenCalledWith(JSON.stringify(automation, null, 2));
+        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 = {};
+        vi.spyOn(console, 'table').mockImplementation(() => { });
+        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 getScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, { id: automationId, appId, name: 'nightly' });
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt.mockResolvedValueOnce(automationId);
+        await getAutomationCommand.action(options, undefined);
+        expect(listScope.isDone()).toBe(true);
+        expect(getScope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Select the automation:', {
+            type: 'select',
+            options: [{ label: 'nightly', value: automationId }],
+        });
+    });
+    it('should exit when no automation matches the name', async () => {
+        const appId = 'app-123';
+        const options = { appId, name: 'missing' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .query({ name: 'missing' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, []);
+        await expect(getAutomationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith('Automation not found.');
+    });
+});

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

@@ -0,0 +1,46 @@
+import appAutomationsService from '../../../services/app-automations.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'List all automations for an app.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        limit: z.coerce.number().optional().describe('Limit for pagination.'),
+        offset: z.coerce.number().optional().describe('Offset for pagination.'),
+        platform: z
+            .enum(['android', 'ios', 'web'], {
+            message: 'Platform must be either `android`, `ios`, or `web`.',
+        })
+            .optional()
+            .describe('Only list automations for this platform.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, json, limit, offset, platform } = 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);
+        }
+        const automations = await appAutomationsService.findAll({
+            appId,
+            limit,
+            offset,
+            platform,
+        });
+        if (json) {
+            console.log(JSON.stringify(automations, null, 2));
+        }
+        else {
+            console.table(automations);
+            consola.success('Automations retrieved successfully.');
+        }
+    }),
+});

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

@@ -0,0 +1,92 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { 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 listAutomationsCommand from './list.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-list', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    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 list automations', async () => {
+        const appId = 'app-123';
+        const automations = [{ id: 'automation-1', appId, name: 'nightly' }];
+        const options = { appId };
+        const tableSpy = vi.spyOn(console, 'table').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, automations);
+        await listAutomationsCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(tableSpy).toHaveBeenCalledWith(automations);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automations retrieved successfully.');
+    });
+    it('should pass pagination and platform filters', async () => {
+        const appId = 'app-123';
+        const options = { appId, limit: 5, offset: 10, platform: 'ios' };
+        vi.spyOn(console, 'table').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .query({ limit: '5', offset: '10', platform: 'ios' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, []);
+        await listAutomationsCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should output JSON when json flag is set', async () => {
+        const appId = 'app-123';
+        const automations = [{ id: 'automation-1', appId, name: 'nightly' }];
+        const options = { appId, json: true };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, automations);
+        await listAutomationsCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(logSpy).toHaveBeenCalledWith(JSON.stringify(automations, null, 2));
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app when not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const options = {};
+        vi.spyOn(console, 'table').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/automations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, []);
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        await listAutomationsCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPromptOrganizationSelection).toHaveBeenCalled();
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId);
+    });
+});

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

@@ -0,0 +1,118 @@
+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';
+const clearableValue = (value) => (value === '' ? null : value);
+export default defineCommand({
+    description: 'Update 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.'),
+        certificate: z
+            .string()
+            .optional()
+            .describe('The name of the certificate to use for the build. Pass an empty string to clear it.'),
+        channel: z
+            .string()
+            .optional()
+            .describe('The name of the channel to deploy to (Web only). Pass an empty string to clear it.'),
+        commitMessagePattern: z
+            .string()
+            .optional()
+            .describe('Only trigger for commits whose message matches this pattern (branch triggers only). Pass an empty string to clear it.'),
+        configuration: z
+            .string()
+            .optional()
+            .describe('The name of the native configuration (Android/iOS only). Pass an empty string to clear it.'),
+        destination: z
+            .string()
+            .optional()
+            .describe('The name of the destination to deploy to (Android/iOS only). Pass an empty string to clear it.'),
+        environment: z
+            .string()
+            .optional()
+            .describe('The name of the environment to use for the build. Pass an empty string to clear it.'),
+        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. Pass an empty string to clear it.'),
+        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, automationId, json } = 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) {
+            if (!isInteractive()) {
+                consola.error('You must provide the automation ID 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 update:', {
+                type: 'select',
+                options: automations.map((automation) => ({ label: automation.name, value: automation.id })),
+            });
+        }
+        await appAutomationsService.update({
+            appCertificateName: clearableValue(options.certificate),
+            appChannelName: clearableValue(options.channel),
+            appConfigurationName: clearableValue(options.configuration),
+            appDestinationName: clearableValue(options.destination),
+            appEnvironmentName: clearableValue(options.environment),
+            appId,
+            automationId,
+            buildStack: options.stack,
+            buildType: options.type,
+            commitMessagePattern: clearableValue(options.commitMessagePattern),
+            name: options.name,
+            platform: options.platform,
+            triggerPattern: clearableValue(options.triggerPattern),
+            triggerType: options.triggerType,
+        });
+        if (json) {
+            console.log(JSON.stringify({ id: automationId }, null, 2));
+        }
+        else {
+            consola.success('Automation updated successfully.');
+        }
+    }),
+});

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

@@ -0,0 +1,124 @@
+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 updateAutomationCommand from './update.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-update', () => {
+    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 update automation with provided options', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = {
+            appId,
+            automationId,
+            configuration: 'Production',
+            name: 'renamed',
+            triggerPattern: 'release/*',
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/automations/${automationId}`, {
+            appConfigurationName: 'Production',
+            name: 'renamed',
+            triggerPattern: 'release/*',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        await updateAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation updated successfully.');
+    });
+    it('should clear a reference when an empty string is passed', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, automationId, certificate: '', triggerPattern: '' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/automations/${automationId}`, {
+            appCertificateName: null,
+            triggerPattern: null,
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        await updateAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Automation updated successfully.');
+    });
+    it('should output JSON when json flag is set', async () => {
+        const appId = 'app-123';
+        const automationId = 'automation-456';
+        const options = { appId, automationId, json: true, name: 'renamed' };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/automations/${automationId}`, { name: 'renamed' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        await updateAutomationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: automationId }, null, 2));
+        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 = { name: 'renamed' };
+        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 updateScope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/automations/${automationId}`, { name: 'renamed' })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(204);
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt.mockResolvedValueOnce(automationId);
+        await updateAutomationCommand.action(options, undefined);
+        expect(listScope.isDone()).toBe(true);
+        expect(updateScope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Select the automation to update:', {
+            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, certificate: 'Missing' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/automations/${automationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(400, { message: 'Certificate with name "Missing" not found for platform "android".' });
+        await expect(updateAutomationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+});

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

@@ -2,6 +2,7 @@ import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
 import appBuildSourcesService from '../../../services/app-build-sources.js';
 import appBuildsService from '../../../services/app-builds.js';
 import appCertificatesService from '../../../services/app-certificates.js';
+import appConfigurationsService from '../../../services/app-configurations.js';
 import appEnvironmentsService from '../../../services/app-environments.js';
 import appsService from '../../../services/apps.js';
 import { getAppBuildShareUrls } from '../../../utils/app-build-shares.js';
@@ -40,6 +41,7 @@ export default defineCommand({
             .describe('App ID to create the build for.'),
         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).'),
+        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).'),
         detached: z
             .boolean()
@@ -102,7 +104,7 @@ export default defineCommand({
         yes: z.boolean().optional().describe('Skip confirmation prompts.'),
     }), { y: 'yes' }),
     action: withAuth(async (options) => {
-        let { appId, platform, type, gitRef, environment, certificate, json, stack, path: sourcePath, url } = options;
+        let { appId, platform, type, gitRef, environment, certificate, configuration, json, stack, path: sourcePath, url, } = options;
         // Validate that detached flag cannot be used with artifact flags
         if (options.detached && (options.apk || options.aab || options.ipa || options.zip)) {
             consola.error('The --detached flag cannot be used with --apk, --aab, --ipa, or --zip flags.');
@@ -251,6 +253,12 @@ export default defineCommand({
             consola.error('The --destination flag cannot be used with the web platform.');
             process.exit(1);
         }
+        // Validate that configuration is only used with the platforms that support it
+        const supportsConfiguration = platform === 'android' || platform === 'ios';
+        if (options.configuration && !supportsConfiguration) {
+            consola.error('The --configuration flag can only be used with the android and ios platforms.');
+            process.exit(1);
+        }
         // Prompt for environment if not provided
         if (!environment && !options.yes && isInteractive()) {
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
@@ -293,6 +301,27 @@ export default defineCommand({
                 }
             }
         }
+        // Prompt for configuration if not provided
+        if (!configuration && supportsConfiguration && !options.yes && isInteractive()) {
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectConfiguration = await prompt('Do you want to select a native configuration?', {
+                type: 'confirm',
+                initial: false,
+            });
+            if (selectConfiguration) {
+                const configurations = await appConfigurationsService.findAll({ appId });
+                if (configurations.length === 0) {
+                    consola.warn('No native configurations found for this app.');
+                }
+                else {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    configuration = await prompt('Select the native configuration for the build:', {
+                        type: 'select',
+                        options: configurations.map((config) => ({ label: config.name, value: config.name })),
+                    });
+                }
+            }
+        }
         // Parse ad hoc environment variables from inline and file
         const variablesMap = new Map();
         if (options.variableFile) {
@@ -348,6 +377,7 @@ export default defineCommand({
             adHocEnvironmentVariables,
             appBuildSourceId,
             appCertificateName: certificate,
+            appConfigurationName: configuration,
             appEnvironmentName: environment,
             appId,
             stack,

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

@@ -92,6 +92,21 @@ describe('apps-builds-create', () => {
         await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
         expect(mockConsola.error).toHaveBeenCalledWith('The --share-description and --share-expires-in-days flags require --share.');
     });
+    it('should reject --configuration combined with a platform that does not support it', async () => {
+        const options = { appId, platform: 'web', gitRef: 'main', configuration: 'production' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The --configuration flag can only be used with the android and ios platforms.');
+    });
+    it.each(['android', 'ios'])('should accept --configuration with the %s platform', async (platform) => {
+        const options = { appId, platform, gitRef: 'main', configuration: 'production', detached: true };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`, (body) => body.appConfigurationName === 'production')
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '42' });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(mockConsola.error).not.toHaveBeenCalled();
+    });
     it('should reject a non-positive shareExpiresInDays value', () => {
         const schema = createCommand.options?.schema;
         for (const shareExpiresInDays of [0, -1]) {