@capawesome/cli 4.22.0 → 4.23.0

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

@@ -1,5 +1,6 @@
 import appDestinationsService from '../../../services/app-destinations.js';
 import { withAuth } from '../../../utils/auth.js';
+import { clearableValue, parseListOption } from '../../../utils/cli-options.js';
 import { isInteractive } from '../../../utils/environment.js';
 import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
 import consola from 'consola';
@@ -18,6 +19,26 @@ export default defineCommand({
         appleApiKeyId: z.string().optional().describe('Apple API Key ID for the destination.'),
         appleIssuerId: z.string().optional().describe('Apple Issuer ID for the destination.'),
         appAppleApiKeyId: z.string().optional().describe('App Apple API Key ID for the destination.'),
+        appleBetaGroup: z
+            .array(z.string())
+            .optional()
+            .describe('Name of an external TestFlight beta group to distribute to. Can be specified multiple times or comma-separated. Pass `--apple-beta-group=` to remove all groups.'),
+        appleSubmitForReview: z
+            .union([z.boolean(), z.stringbool()], {
+            message: 'Apple submit for review must be either `true` or `false`.',
+        })
+            .optional()
+            .describe('Submit the build for App Review after the upload (App Store Connect only, requires an API key).'),
+        appleReleaseType: z
+            .enum(['after-approval', 'manual'])
+            .optional()
+            .describe('Release type of the App Store version after approval (App Store Connect only).'),
+        appleRejectIfPossible: z
+            .union([z.boolean(), z.stringbool()], {
+            message: 'Apple reject if possible must be either `true` or `false`.',
+        })
+            .optional()
+            .describe('Cancel a submission waiting for review before submitting the new build (App Store Connect only).'),
         androidPackageName: z.string().optional().describe('Android package name for the destination.'),
         androidBuildArtifactType: z.enum(['aab', 'apk']).optional().describe('Android build artifact type (aab, apk).'),
         androidReleaseStatus: z
@@ -29,9 +50,24 @@ export default defineCommand({
             .optional()
             .describe('App Google Service Account Key ID for the destination.'),
         googlePlayTrack: z.string().optional().describe('Google Play track for the destination.'),
+        firebaseAppId: z.string().optional().describe('Firebase app ID for the destination.'),
+        firebaseTesterGroup: z
+            .array(z.string())
+            .optional()
+            .describe('The alias of a Firebase tester group to distribute to. Can be specified multiple times or comma-separated. Pass `--firebase-tester-group=` to remove all groups.'),
+        huaweiAppId: z.string().optional().describe('Huawei AppGallery app ID for the destination.'),
+        huaweiClientId: z.string().optional().describe('Huawei AppGallery Connect API client ID for the destination.'),
+        huaweiClientSecret: z
+            .string()
+            .optional()
+            .describe('Huawei AppGallery Connect API client secret for the destination.'),
+        defaultLanguage: z
+            .string()
+            .optional()
+            .describe('Language of the default release notes text, e.g. `en-US` (Google Play and Huawei AppGallery only). Pass `--default-language=` to clear it.'),
     })),
     action: withAuth(async (options, args) => {
-        let { appId, destinationId, name, appleId, appleAppId, appleTeamId, appleAppPassword, appleApiKeyId, appleIssuerId, appAppleApiKeyId, androidPackageName, androidBuildArtifactType, androidReleaseStatus, appGoogleServiceAccountKeyId, googlePlayTrack, } = options;
+        let { appId, destinationId, name, appleId, appleAppId, appleTeamId, appleAppPassword, appleApiKeyId, appleIssuerId, appAppleApiKeyId, appleBetaGroup, appleSubmitForReview, appleReleaseType, appleRejectIfPossible, androidPackageName, androidBuildArtifactType, androidReleaseStatus, appGoogleServiceAccountKeyId, googlePlayTrack, firebaseAppId, firebaseTesterGroup, huaweiAppId, huaweiClientId, huaweiClientSecret, defaultLanguage, } = options;
         if (!appId) {
             if (!isInteractive()) {
                 consola.error('You must provide an app ID when running in non-interactive environment.');
@@ -58,11 +94,21 @@ export default defineCommand({
             appleApiKeyId,
             appleIssuerId,
             appAppleApiKeyId,
+            appleBetaGroups: parseListOption(appleBetaGroup),
+            appleRejectIfPossible,
+            appleReleaseType,
+            appleSubmitForReview,
             androidPackageName,
             androidBuildArtifactType,
             androidReleaseStatus,
             appGoogleServiceAccountKeyId,
             googlePlayTrack,
+            firebaseAppId,
+            firebaseTesterGroups: parseListOption(firebaseTesterGroup),
+            huaweiAppId,
+            huaweiClientId,
+            huaweiClientSecret,
+            defaultLanguage: clearableValue(defaultLanguage),
         });
         consola.success('Destination updated successfully.');
     }),

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

@@ -0,0 +1,138 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.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 updateDestinationCommand 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: () => false,
+}));
+describe('apps-destinations-update', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const appId = 'app-123';
+    const destinationId = 'destination-456';
+    const testToken = 'test-token';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(testToken);
+        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 the Firebase and Huawei fields', async () => {
+        const options = {
+            appId,
+            destinationId,
+            firebaseAppId: '1:123456789012:android:0a1b2c3d4e5f67890',
+            firebaseTesterGroup: ['qa-team,beta-testers'],
+            huaweiAppId: '112233445',
+            huaweiClientId: 'client-id',
+            huaweiClientSecret: 'client-secret',
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, {
+            appId,
+            destinationId,
+            firebaseAppId: '1:123456789012:android:0a1b2c3d4e5f67890',
+            firebaseTesterGroups: ['qa-team', 'beta-testers'],
+            huaweiAppId: '112233445',
+            huaweiClientId: 'client-id',
+            huaweiClientSecret: 'client-secret',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Destination updated successfully.');
+    });
+    it('should update the Apple submission settings', async () => {
+        const options = {
+            appId,
+            destinationId,
+            appleBetaGroup: ['External Testers,QA'],
+            appleSubmitForReview: false,
+            appleReleaseType: 'manual',
+            appleRejectIfPossible: true,
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, {
+            appId,
+            destinationId,
+            appleBetaGroups: ['External Testers', 'QA'],
+            appleRejectIfPossible: true,
+            appleReleaseType: 'manual',
+            appleSubmitForReview: false,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should update the default language', async () => {
+        const options = { appId, destinationId, defaultLanguage: 'en-US' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, { appId, destinationId, defaultLanguage: 'en-US' })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should clear the default language when `--default-language=` is passed', async () => {
+        const options = { appId, destinationId, defaultLanguage: '' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, { appId, destinationId, defaultLanguage: null })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should parse the boolean Apple flags from `true` and `false` values', () => {
+        const schema = updateDestinationCommand.options?.schema;
+        const result = schema?.safeParse({ appleSubmitForReview: 'false', appleRejectIfPossible: true });
+        expect(result?.success).toBe(true);
+        expect(result?.data?.appleSubmitForReview).toBe(false);
+        expect(result?.data?.appleRejectIfPossible).toBe(true);
+    });
+    it('should reject a boolean Apple flag with an invalid value', () => {
+        const schema = updateDestinationCommand.options?.schema;
+        const result = schema?.safeParse({ appleSubmitForReview: 'maybe' });
+        expect(result?.success).toBe(false);
+        expect(result?.error?.issues[0]?.message).toBe('Apple submit for review must be either `true` or `false`.');
+    });
+    it('should clear the Firebase tester groups when `--firebase-tester-group=` is passed', async () => {
+        const options = { appId, destinationId, firebaseTesterGroup: [''] };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, {
+            appId,
+            destinationId,
+            firebaseTesterGroups: [],
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should not send the Firebase tester groups when `--firebase-tester-group` is not passed', async () => {
+        const options = { appId, destinationId, huaweiAppId: '112233445' };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/destinations/${destinationId}`, (body) => !('firebaseTesterGroups' in body))
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: destinationId });
+        await updateDestinationCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/import.js

@@ -12,6 +12,7 @@ import gitConnectionsService from '../../services/git-connections.js';
 import { generateUniqueName, isNameTaken } from '../../utils/app-import.js';
 import { parseAppflowExport } from '../../utils/appflow-export.js';
 import { withAuth } from '../../utils/auth.js';
+import { parseListOption } from '../../utils/cli-options.js';
 import { isInteractive } from '../../utils/environment.js';
 import { getMessageFromUnknownError, UserError } from '../../utils/error.js';
 import { isReadable } from '../../utils/file.js';
@@ -150,10 +151,7 @@ export default defineCommand({
     }),
 });
 const selectApps = async (apps, skippedApps, include) => {
-    const filters = include
-        ?.flatMap((value) => value.split(','))
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
+    const filters = parseListOption(include);
     if (filters && filters.length > 0) {
         const matchesFilter = (sourceId, sourceName) => filters.some((filter) => filter === sourceId || filter === sourceName);
         for (const filter of filters) {

package/dist/utils/appflow-export.js

@@ -8,6 +8,11 @@ const SUPPORTED_MANIFEST_MAJOR_VERSION = 'v1';
 const WEBHOOKS_DOCS_URL = 'https://capawesome.io/docs/cloud/webhooks/';
 const LIVE_UPDATES_DOCS_URL = 'https://capawesome.io/docs/cloud/live-updates/';
 const SUPPORTED_BUILD_TYPES = ['ad-hoc', 'app-store', 'debug', 'development', 'enterprise', 'release', 'simulator'];
+// Appflow pins tool versions through these variables. Capawesome Cloud reads them under its own names.
+const APPFLOW_VARIABLE_RENAMES = new Map([
+    ['OVERRIDE_JAVA_VERSION', 'JAVA_VERSION'],
+    ['OVERRIDE_NODE_VERSION', 'NODE_VERSION'],
+]);
 const manifestSchema = z.object({
     version: z.string().nullish(),
 });
@@ -190,14 +195,31 @@ const parseApp = (appFolder, detail, type) => {
         channels: channels.map((channel) => channel.name),
         configurations: parseConfigurations(nativeConfigs, notes),
         destinations: destinations.map(({ id, ...destination }) => destination),
-        environments: environments.map((environment) => ({
-            name: environment.name,
-            variables: Object.entries(environment.vars ?? {}).map(([key, value]) => ({ key, value })),
-            secrets: Object.entries(environment.secrets ?? {}).map(([key, value]) => ({ key, value })),
-        })),
+        environments: environments.map((environment) => parseEnvironment(environment, notes)),
         repository: parseRepository(appFolder, notes),
     };
 };
+const parseEnvironment = (environment, notes) => ({
+    name: environment.name,
+    variables: renameAppflowVariables(environment.name, toEnvironmentVariables(environment.vars), notes),
+    secrets: toEnvironmentVariables(environment.secrets),
+});
+const toEnvironmentVariables = (record) => Object.entries(record ?? {}).map(([key, value]) => ({ key, value }));
+const renameAppflowVariables = (environmentName, variables, notes) => {
+    const keys = new Set(variables.map((variable) => variable.key));
+    return variables.map((variable) => {
+        const renamedKey = APPFLOW_VARIABLE_RENAMES.get(variable.key);
+        if (!renamedKey) {
+            return variable;
+        }
+        if (keys.has(renamedKey)) {
+            notes.push(`The environment \`${environmentName}\` contains both \`${variable.key}\` and \`${renamedKey}\`. Capawesome Cloud only reads \`${renamedKey}\`.`);
+            return variable;
+        }
+        notes.push(`The variable \`${variable.key}\` of the environment \`${environmentName}\` was renamed to \`${renamedKey}\`, the name Capawesome Cloud reads.`);
+        return { ...variable, key: renamedKey };
+    });
+};
 const parseRepository = (appFolder, notes) => {
     const repoAssociation = parseJsonFileIfExists(path.join(appFolder, 'repo-association.json'), repoAssociationSchema);
     if (!repoAssociation || Array.isArray(repoAssociation)) {

package/dist/utils/appflow-export.test.js

@@ -388,6 +388,39 @@ describe('appflow-export', () => {
         expect(apps[0].notes).toContainEqual(expect.stringContaining(`\`${sanitizedUrl}\``));
         expect(JSON.stringify(apps[0].notes)).not.toContain('secret-token');
     });
+    it('should rename the Appflow tool version variables', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+            'environments.json': [
+                {
+                    id: 1,
+                    name: 'Production',
+                    vars: { OVERRIDE_JAVA_VERSION: '21', OVERRIDE_NODE_VERSION: '22' },
+                    secrets: null,
+                },
+            ],
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].environments[0].variables).toEqual([
+            { key: 'JAVA_VERSION', value: '21' },
+            { key: 'NODE_VERSION', value: '22' },
+        ]);
+        expect(apps[0].notes).toContainEqual(expect.stringContaining('`OVERRIDE_NODE_VERSION`'));
+    });
+    it('should keep an Appflow tool version variable if the Capawesome Cloud name is taken', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+            'environments.json': [
+                { id: 1, name: 'Production', vars: { NODE_VERSION: '20', OVERRIDE_NODE_VERSION: '22' }, secrets: null },
+            ],
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].environments[0].variables).toEqual([
+            { key: 'NODE_VERSION', value: '20' },
+            { key: 'OVERRIDE_NODE_VERSION', value: '22' },
+        ]);
+        expect(apps[0].notes).toContainEqual(expect.stringContaining('contains both'));
+    });
     it('should skip an app with an invalid app detail file', async () => {
         writeAppFiles('Invalid-66666666', {
             'app-detail.json': 'not json',

package/dist/utils/cli-options.js

@@ -0,0 +1,7 @@
+export const clearableValue = (value) => (value === '' ? null : value);
+export const parseListOption = (values) => {
+    return values
+        ?.flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+};

package/dist/utils/cli-options.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { parseListOption } from './cli-options.js';
+describe('parseListOption', () => {
+    it('should return undefined if the option is not passed', () => {
+        expect(parseListOption(undefined)).toBeUndefined();
+    });
+    it('should split comma-separated values and trim them', () => {
+        expect(parseListOption(['qa-team, beta-testers', 'internal'])).toEqual(['qa-team', 'beta-testers', 'internal']);
+    });
+    it('should drop empty values', () => {
+        expect(parseListOption(['qa-team,, ', ''])).toEqual(['qa-team']);
+    });
+    it('should return an empty list if only an empty value is passed', () => {
+        expect(parseListOption([''])).toEqual([]);
+    });
+});

package/dist/utils/release-notes.js

@@ -0,0 +1,55 @@
+import consola from 'consola';
+import fs from 'fs/promises';
+import { z } from 'zod';
+const releaseNotesFileSchema = z.record(z.string(), z.string()).refine((releaseNotes) => 'default' in releaseNotes);
+export const parseReleaseNotes = async (options) => {
+    const { releaseNotes, releaseNotesFile, releaseNotesLocale } = options;
+    if (releaseNotesFile !== undefined) {
+        if (releaseNotes !== undefined || releaseNotesLocale !== undefined) {
+            consola.error('The --release-notes-file flag cannot be used together with --release-notes or --release-notes-locale.');
+            process.exit(1);
+        }
+        return readReleaseNotesFile(releaseNotesFile);
+    }
+    if (releaseNotes === undefined && releaseNotesLocale === undefined) {
+        return undefined;
+    }
+    if (releaseNotes === undefined) {
+        consola.error('Release notes require a default text (--release-notes).');
+        process.exit(1);
+    }
+    return { default: releaseNotes, ...parseLocalizedReleaseNotes(releaseNotesLocale ?? []) };
+};
+const parseLocalizedReleaseNotes = (entries) => {
+    const localizedReleaseNotes = {};
+    for (const entry of entries) {
+        const separatorIndex = entry.indexOf('=');
+        if (separatorIndex <= 0) {
+            consola.error(`Invalid release notes locale \`${entry}\`. Use the format \`<locale>=<text>\`.`);
+            process.exit(1);
+        }
+        const locale = entry.slice(0, separatorIndex);
+        if (locale === 'default') {
+            consola.error('The locale `default` is reserved. Use --release-notes for the default text.');
+            process.exit(1);
+        }
+        localizedReleaseNotes[locale] = entry.slice(separatorIndex + 1);
+    }
+    return localizedReleaseNotes;
+};
+const readReleaseNotesFile = async (filePath) => {
+    let json;
+    try {
+        json = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    }
+    catch {
+        consola.error(`The release notes file is missing or contains invalid JSON: ${filePath}`);
+        process.exit(1);
+    }
+    const result = releaseNotesFileSchema.safeParse(json);
+    if (!result.success) {
+        consola.error('The release notes file must contain a JSON object of texts by locale with a `default` key.');
+        process.exit(1);
+    }
+    return result.data;
+};

package/dist/utils/release-notes.test.js

@@ -0,0 +1,74 @@
+import consola from 'consola';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { parseReleaseNotes } from './release-notes.js';
+vi.mock('consola');
+describe('parseReleaseNotes', () => {
+    const mockConsola = vi.mocked(consola);
+    let tempDirectory;
+    let releaseNotesFile;
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        tempDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'capawesome-cli-release-notes-'));
+        releaseNotesFile = path.join(tempDirectory, 'release-notes.json');
+    });
+    afterEach(async () => {
+        vi.restoreAllMocks();
+        await fs.rm(tempDirectory, { force: true, recursive: true });
+    });
+    it('should return undefined if no release notes are passed', async () => {
+        await expect(parseReleaseNotes({})).resolves.toBeUndefined();
+    });
+    it('should use the release notes as the default text', async () => {
+        await expect(parseReleaseNotes({ releaseNotes: 'Bug fixes' })).resolves.toEqual({ default: 'Bug fixes' });
+    });
+    it('should add the translated release notes split at the first `=`', async () => {
+        const releaseNotes = await parseReleaseNotes({
+            releaseNotes: 'Bug fixes',
+            releaseNotesLocale: ['de-DE=Fehlerbehebungen', 'fr-FR=Corrections = bugs'],
+        });
+        expect(releaseNotes).toEqual({ default: 'Bug fixes', 'de-DE': 'Fehlerbehebungen', 'fr-FR': 'Corrections = bugs' });
+    });
+    it('should reject translated release notes without a default text', async () => {
+        await expect(parseReleaseNotes({ releaseNotesLocale: ['de-DE=Fehlerbehebungen'] })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('Release notes require a default text (--release-notes).');
+    });
+    it('should reject translated release notes without a locale', async () => {
+        await expect(parseReleaseNotes({ releaseNotes: 'Bug fixes', releaseNotesLocale: ['Fehlerbehebungen'] })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('Invalid release notes locale `Fehlerbehebungen`. Use the format `<locale>=<text>`.');
+    });
+    it('should reject translated release notes for the reserved `default` locale', async () => {
+        await expect(parseReleaseNotes({ releaseNotes: 'Bug fixes', releaseNotesLocale: ['default=Fehlerbehebungen'] })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The locale `default` is reserved. Use --release-notes for the default text.');
+    });
+    it('should read the release notes from a file', async () => {
+        await fs.writeFile(releaseNotesFile, JSON.stringify({ default: 'Bug fixes', 'de-DE': 'Fehlerbehebungen' }));
+        await expect(parseReleaseNotes({ releaseNotesFile })).resolves.toEqual({
+            default: 'Bug fixes',
+            'de-DE': 'Fehlerbehebungen',
+        });
+    });
+    it('should reject a file combined with other release notes flags', async () => {
+        await expect(parseReleaseNotes({ releaseNotes: 'Bug fixes', releaseNotesFile })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The --release-notes-file flag cannot be used together with --release-notes or --release-notes-locale.');
+    });
+    it('should reject a file without a default text', async () => {
+        await fs.writeFile(releaseNotesFile, JSON.stringify({ 'de-DE': 'Fehlerbehebungen' }));
+        await expect(parseReleaseNotes({ releaseNotesFile })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The release notes file must contain a JSON object of texts by locale with a `default` key.');
+    });
+    it('should reject a file with invalid JSON', async () => {
+        await fs.writeFile(releaseNotesFile, 'Bug fixes');
+        await expect(parseReleaseNotes({ releaseNotesFile })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith(`The release notes file is missing or contains invalid JSON: ${releaseNotesFile}`);
+    });
+    it('should reject an empty file path', async () => {
+        await expect(parseReleaseNotes({ releaseNotesFile: '' })).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The release notes file is missing or contains invalid JSON: ');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "4.22.0",
+  "version": "4.23.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {