@capawesome/cli 4.17.2 → 4.18.0

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

@@ -0,0 +1,265 @@
+import appBuildsService from '../../../services/app-builds.js';
+import { bootAndroidEmulator, findAllAndroidEmulators, installAndroidApp, launchAndroidApp, } from '../../../utils/android-emulator.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { bootIosSimulator, findAllIosSimulators, installIosApp, launchIosApp, } from '../../../utils/ios-simulator.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import zip from '../../../utils/zip.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Run an app build on a local emulator or simulator.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID the build belongs to.'),
+        buildId: z
+            .uuid({
+            message: 'Build ID must be a UUID.',
+        })
+            .optional()
+            .describe('Build ID to run.'),
+        buildNumber: z.string().optional().describe('Build number to run (e.g., "1", "42").'),
+        target: z.string().optional().describe('Run on a specific target device by its ID.'),
+        targetName: z
+            .string()
+            .optional()
+            .describe('Run on a specific target device by its name (e.g. "Pixel 8 Pro", "iPhone 17 Pro").'),
+        targetNameSdkVersion: z
+            .string()
+            .optional()
+            .describe('Run on a target device by name with a specific SDK version when using --target-name (e.g. "26.5" for iOS 26.5 or "35" for Android API 35).'),
+    })),
+    action: withAuth(async (options) => {
+        let { appId, buildId } = options;
+        const { buildNumber, target, targetName, targetNameSdkVersion } = options;
+        if (targetNameSdkVersion && !targetName) {
+            consola.error('You must provide --target-name when using --target-name-sdk-version.');
+            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 organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        // Convert build number to build ID if provided
+        if (!buildId && buildNumber) {
+            const builds = await appBuildsService.findAll({ appId, numberAsString: buildNumber });
+            if (builds.length === 0) {
+                consola.error(`Build #${buildNumber} not found.`);
+                process.exit(1);
+            }
+            buildId = builds[0]?.id;
+        }
+        // Prompt for build ID if not provided
+        if (!buildId) {
+            if (!isInteractive()) {
+                consola.error('You must provide a build ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const builds = await appBuildsService.findAll({ appId });
+            if (builds.length === 0) {
+                consola.error('No builds found for this app.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            buildId = await prompt('Select the build you want to run:', {
+                type: 'select',
+                options: builds.map((build) => ({
+                    label: `Build #${build.numberAsString || build.id} (${build.platform} - ${build.type})`,
+                    value: build.id,
+                })),
+            });
+            if (!buildId) {
+                consola.error('You must select a build to run.');
+                process.exit(1);
+            }
+        }
+        const build = await appBuildsService.findOne({ appId, appBuildId: buildId, relations: 'appBuildArtifacts,job' });
+        const packageName = validateAppBuild(build);
+        const isAndroid = build.platform === 'android';
+        const androidTargets = isAndroid ? findAllAndroidEmulators().map(toAndroidTarget) : [];
+        const iosTargets = isAndroid ? [] : findAllIosSimulators().map(toIosTarget);
+        const targets = isAndroid ? androidTargets : iosTargets;
+        if (targets.length === 0) {
+            consola.error(isAndroid
+                ? 'No Android emulators found. Create one in Android Studio and try again.'
+                : 'No iOS simulators found. Install one via Xcode and try again.');
+            process.exit(1);
+        }
+        const artifactType = isAndroid ? 'apk' : 'app';
+        const artifact = build.appBuildArtifacts?.find((artifact) => artifact.type === artifactType && artifact.status === 'ready');
+        if (!artifact) {
+            consola.error(`No ${artifactType.toUpperCase()} artifact is available for this build.`);
+            process.exit(1);
+        }
+        consola.start('Downloading build...');
+        const artifactData = await appBuildsService.downloadArtifact({
+            appId,
+            appBuildId: buildId,
+            artifactId: artifact.id,
+        });
+        const temporaryDirectoryPath = await fs.mkdtemp(path.join(os.tmpdir(), 'capawesome-'));
+        consola.success('Build downloaded.');
+        const targetSelection = { target, targetName, targetNameSdkVersion };
+        try {
+            if (isAndroid) {
+                const apkPath = path.join(temporaryDirectoryPath, 'app.apk');
+                await fs.writeFile(apkPath, Buffer.from(artifactData));
+                await handleAndroidRun({ apkPath, packageName, targets: androidTargets, targetSelection });
+            }
+            else {
+                const appPath = await extractAppBundle(Buffer.from(artifactData), temporaryDirectoryPath);
+                await handleIosRun({ appPath, packageName, targets: iosTargets, targetSelection });
+            }
+        }
+        finally {
+            await fs.rm(temporaryDirectoryPath, { force: true, recursive: true });
+        }
+    }),
+});
+/**
+ * Ensure the build can be run locally and return its package name.
+ */
+const validateAppBuild = (build) => {
+    if (build.job?.status !== 'succeeded') {
+        consola.error('The build has not succeeded yet. Cannot run incomplete builds.');
+        process.exit(1);
+    }
+    if (build.platform === 'web') {
+        consola.error('Web builds cannot be run on an emulator or simulator.');
+        process.exit(1);
+    }
+    if (build.platform === 'ios') {
+        if (process.platform !== 'darwin') {
+            consola.error('iOS builds can only be run on macOS.');
+            process.exit(1);
+        }
+        if (build.type !== 'simulator') {
+            consola.error(`Only iOS builds of the type "simulator" can be run on a simulator. This build has the type "${build.type}".`);
+            process.exit(1);
+        }
+    }
+    if (!build.packageName) {
+        consola.error('The package name of this build is unknown. Please create a new build and try again.');
+        process.exit(1);
+    }
+    return build.packageName;
+};
+/**
+ * Extract the app bundle from the downloaded artifact and return its path.
+ */
+const extractAppBundle = async (artifactData, targetFolder) => {
+    await zip.unzipToFolder(artifactData, targetFolder);
+    const entries = await fs.readdir(targetFolder);
+    const appBundleName = entries.find((entry) => entry.endsWith('.app'));
+    if (!appBundleName) {
+        consola.error('The downloaded artifact does not contain an app bundle.');
+        process.exit(1);
+    }
+    return path.join(targetFolder, appBundleName);
+};
+const toAndroidTarget = (emulator) => ({
+    device: emulator,
+    id: emulator.id,
+    label: emulator.sdkVersion ? `${emulator.name} (API ${emulator.sdkVersion})` : emulator.name,
+    name: emulator.name,
+    running: emulator.running,
+    sdkVersion: emulator.sdkVersion,
+});
+const toIosTarget = (simulator) => ({
+    device: simulator,
+    id: simulator.id,
+    label: `${simulator.name} (iOS ${simulator.sdkVersion})`,
+    name: simulator.name,
+    running: simulator.running,
+    sdkVersion: simulator.sdkVersion,
+});
+/**
+ * Select the target device to run the build on, preferring targets that are already running.
+ */
+const selectTarget = async (targets, selection) => {
+    const sortedTargets = [...targets].sort((target, otherTarget) => Number(otherTarget.running) - Number(target.running));
+    if (selection.target) {
+        const matchingTarget = sortedTargets.find((target) => target.id === selection.target);
+        if (!matchingTarget) {
+            consola.error(`No target device with the ID "${selection.target}" was found.`);
+            process.exit(1);
+        }
+        return matchingTarget.device;
+    }
+    if (selection.targetName) {
+        const matchingTargets = sortedTargets.filter((target) => target.name === selection.targetName &&
+            (!selection.targetNameSdkVersion || target.sdkVersion === selection.targetNameSdkVersion));
+        const matchingTarget = matchingTargets[0];
+        if (!matchingTarget) {
+            consola.error(`No target device named "${selection.targetName}" was found.`);
+            process.exit(1);
+        }
+        if (matchingTargets.length > 1) {
+            consola.warn(`Multiple target devices named "${selection.targetName}" were found. Using "${matchingTarget.label}". Use --target-name-sdk-version or --target to select a specific one.`);
+        }
+        return matchingTarget.device;
+    }
+    if (!isInteractive()) {
+        consola.error('You must provide a target device when running in non-interactive environment.');
+        process.exit(1);
+    }
+    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+    const selectedIndex = await prompt('Select the target device you want to run the build on:', {
+        type: 'select',
+        options: sortedTargets.map((target, index) => ({
+            label: target.running ? `${target.label} (running)` : target.label,
+            value: `${index}`,
+        })),
+    });
+    const selectedTarget = sortedTargets[Number(selectedIndex)];
+    if (!selectedTarget) {
+        consola.error('You must select a target device to run the build on.');
+        process.exit(1);
+    }
+    return selectedTarget.device;
+};
+/**
+ * Run an Android build on a local emulator.
+ */
+const handleAndroidRun = async (options) => {
+    const { apkPath, packageName, targets, targetSelection } = options;
+    const emulator = await selectTarget(targets, targetSelection);
+    consola.start(emulator.running ? `Using emulator "${emulator.name}"...` : `Starting emulator "${emulator.name}"...`);
+    const serial = await bootAndroidEmulator(emulator);
+    consola.success(`Emulator "${emulator.name}" is running.`);
+    consola.start('Installing app...');
+    installAndroidApp(serial, apkPath);
+    consola.success('App installed.');
+    consola.start('Launching app...');
+    launchAndroidApp(serial, packageName);
+    consola.success('App launched.');
+};
+/**
+ * Run an iOS build on a local simulator.
+ */
+const handleIosRun = async (options) => {
+    const { appPath, packageName, targets, targetSelection } = options;
+    const simulator = await selectTarget(targets, targetSelection);
+    consola.start(simulator.running ? `Using simulator "${simulator.name}"...` : `Starting simulator "${simulator.name}"...`);
+    bootIosSimulator(simulator);
+    consola.success(`Simulator "${simulator.name}" is running.`);
+    consola.start('Installing app...');
+    installIosApp(simulator.id, appPath);
+    consola.success('App installed.');
+    consola.start('Launching app...');
+    launchIosApp(simulator.id, packageName);
+    consola.success('App launched.');
+};

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

@@ -0,0 +1,51 @@
+import appConfigurationsService from '../../../services/app-configurations.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 native configuration.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        displayName: z.string().optional().describe('Display name of the app.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        name: z.string().optional().describe('Name of the native configuration.'),
+        packageName: z
+            .string()
+            .optional()
+            .describe('Package name of the app (application ID on Android, bundle ID on iOS).'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, displayName, json, name, packageName } = 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({ allowCreate: true });
+            appId = await promptAppSelection(organizationId, { allowCreate: true });
+        }
+        if (!name) {
+            if (!isInteractive()) {
+                consola.error('You must provide the native configuration name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            name = await prompt('Enter the name of the native configuration:', { type: 'text' });
+        }
+        const response = await appConfigurationsService.create({
+            appId,
+            displayName: displayName === '' ? null : displayName,
+            name,
+            packageName: packageName === '' ? null : packageName,
+        });
+        if (json) {
+            console.log(JSON.stringify({ id: response.id }, null, 2));
+        }
+        else {
+            consola.info(`Native configuration ID: ${response.id}`);
+            consola.success('Native configuration created successfully.');
+        }
+    }),
+});

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

@@ -0,0 +1,120 @@
+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 createConfigurationCommand 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-configurations-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 configuration with provided options', async () => {
+        const appId = 'app-123';
+        const configurationName = 'production';
+        const displayName = 'My App';
+        const packageName = 'io.capawesome.app';
+        const configurationId = 'configuration-456';
+        const testToken = 'test-token';
+        const options = { appId, displayName, name: configurationName, packageName };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/configurations`, {
+            displayName,
+            name: configurationName,
+            packageName,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: configurationId, name: configurationName });
+        await createConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Native configuration ID: ${configurationId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Native configuration created successfully.');
+    });
+    it('should output JSON when json flag is set', async () => {
+        const appId = 'app-123';
+        const configurationName = 'production';
+        const configurationId = 'configuration-456';
+        const testToken = 'test-token';
+        const options = { appId, json: true, name: configurationName };
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/configurations`, {
+            name: configurationName,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: configurationId, name: configurationName });
+        await createConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: configurationId }, null, 2));
+        expect(mockConsola.info).not.toHaveBeenCalled();
+    });
+    it('should prompt for app when not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const configurationName = 'staging';
+        const configurationId = 'configuration-456';
+        const testToken = 'test-token';
+        const options = { name: configurationName };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/configurations`, {
+            name: configurationName,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: configurationId, name: configurationName });
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        await createConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPromptOrganizationSelection).toHaveBeenCalledWith({ allowCreate: true });
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId, { allowCreate: true });
+        expect(mockConsola.success).toHaveBeenCalledWith('Native configuration created successfully.');
+    });
+    it('should prompt for configuration name when not provided', async () => {
+        const options = { appId: 'app-123' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post('/v1/apps/app-123/configurations', {
+            name: 'development',
+        })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(201, { id: 'configuration-456', name: 'development' });
+        mockPrompt.mockResolvedValueOnce('development');
+        await createConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Enter the name of the native configuration:', { type: 'text' });
+    });
+    it('should handle API error', async () => {
+        const options = { appId: 'app-123', name: 'production' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post('/v1/apps/app-123/configurations')
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(400, { message: 'Configuration name already exists' });
+        await expect(createConfigurationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,61 @@
+import appConfigurationsService from '../../../services/app-configurations.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 a native configuration.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        configurationId: z
+            .string()
+            .optional()
+            .describe('ID of the native configuration. Either the ID or name must be provided.'),
+        name: z.string().optional().describe('Name of the native configuration. 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, configurationId, 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 (!configurationId && !name) {
+            if (!isInteractive()) {
+                consola.error('You must provide either the native configuration ID or name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const configurations = await appConfigurationsService.findAll({ appId });
+            if (!configurations.length) {
+                consola.error('No native configurations found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectedConfigurationId = await prompt('Select the native configuration to delete:', {
+                type: 'select',
+                options: configurations.map((configuration) => ({ label: configuration.name, value: configuration.id })),
+            });
+            configurationId = selectedConfigurationId;
+        }
+        if (!options.yes && isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to delete this native configuration?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appConfigurationsService.delete({
+            appId,
+            id: configurationId,
+            name,
+        });
+        consola.success('Native configuration deleted successfully.');
+    }),
+});

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

@@ -0,0 +1,112 @@
+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 deleteConfigurationCommand 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-configurations-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 configuration by ID after confirmation', async () => {
+        const appId = 'app-123';
+        const configurationId = 'configuration-456';
+        const options = { appId, configurationId };
+        mockPrompt.mockResolvedValueOnce(true); // confirmation
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/configurations/${configurationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200);
+        await deleteConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this native configuration?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Native configuration deleted successfully.');
+    });
+    it('should delete configuration by name when yes flag is set', async () => {
+        const appId = 'app-123';
+        const configurationName = 'production';
+        const options = { appId, name: configurationName, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/configurations`)
+            .query({ name: configurationName })
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200);
+        await deleteConfigurationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).not.toHaveBeenCalled();
+        expect(mockConsola.success).toHaveBeenCalledWith('Native configuration deleted successfully.');
+    });
+    it('should not delete configuration when confirmation is declined', async () => {
+        const options = { appId: 'app-123', configurationId: 'configuration-456' };
+        mockPrompt.mockResolvedValueOnce(false); // declined confirmation
+        await deleteConfigurationCommand.action(options, undefined);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app and configuration when not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const configurationId = 'configuration-456';
+        const configurationName = 'development';
+        const options = {};
+        const listScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/configurations`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200, [{ id: configurationId, appId, name: configurationName }]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/configurations/${configurationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(200);
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt
+            .mockResolvedValueOnce(configurationId) // configuration selection
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteConfigurationCommand.action(options, undefined);
+        expect(listScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Select the native configuration to delete:', {
+            type: 'select',
+            options: [{ label: configurationName, value: configurationId }],
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Native configuration deleted successfully.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const configurationId = 'configuration-456';
+        const options = { appId, configurationId, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/configurations/${configurationId}`)
+            .matchHeader('Authorization', 'Bearer test-token')
+            .reply(404, { message: 'Configuration not found' });
+        await expect(deleteConfigurationCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});