@capawesome/cli 2.1.4-dev.6aa4113.1756747594 → 2.1.4-dev.6aa4113.1756747595

package/dist/commands/mutate/version/get.js

@@ -1,53 +1,47 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
 export default defineCommand({
     description: 'Get the version of the app from all relevant files',
     action: async () => {
-        try {
-            const versions = await versionService.getAllVersions();
-            if (versions.length === 0) {
-                consola.error('No platform versions found');
-                process.exit(1);
-            }
-            const firstVersion = versions[0].version;
-            // Check major.minor.patch synchronization for all platforms
-            const allVersionsInSync = versions.every((pv) => {
-                return (pv.version.major === firstVersion.major &&
-                    pv.version.minor === firstVersion.minor &&
-                    pv.version.patch === firstVersion.patch);
-            });
-            // Check hotfix synchronization between iOS and Android
-            const iosVersion = versions.find((pv) => pv.platform === 'ios');
-            const androidVersion = versions.find((pv) => pv.platform === 'android');
-            let hotfixInSync = true;
-            if (iosVersion && androidVersion) {
-                const iosHotfix = iosVersion.version.hotfix || 0;
-                const androidHotfix = androidVersion.version.hotfix || 0;
-                hotfixInSync = iosHotfix === androidHotfix;
-            }
-            if (!allVersionsInSync || !hotfixInSync) {
-                consola.error('Versions are not synchronized across platforms:');
-                versions.forEach((pv) => {
-                    const versionStr = versionToString(pv.version);
-                    const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
-                    consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr} (${pv.source})`);
-                });
-                process.exit(1);
-            }
-            const versionStr = versionToString(firstVersion);
-            // Show hotfix if iOS or Android has one
-            const platformWithHotfix = versions.find((pv) => pv.platform !== 'web' && pv.version.hotfix && pv.version.hotfix > 0);
-            const hotfixStr = platformWithHotfix ? ` (hotfix: ${platformWithHotfix.version.hotfix})` : '';
-            consola.success(`Version: ${versionStr}${hotfixStr}`);
+        const versions = await versionService.getAllVersions();
+        if (versions.length === 0) {
+            throw new CliError('No platform versions found');
+        }
+        const firstVersion = versions[0].version;
+        // Check major.minor.patch synchronization for all platforms
+        const allVersionsInSync = versions.every((pv) => {
+            return (pv.version.major === firstVersion.major &&
+                pv.version.minor === firstVersion.minor &&
+                pv.version.patch === firstVersion.patch);
+        });
+        // Check hotfix synchronization between iOS and Android
+        const iosVersion = versions.find((pv) => pv.platform === 'ios');
+        const androidVersion = versions.find((pv) => pv.platform === 'android');
+        let hotfixInSync = true;
+        if (iosVersion && androidVersion) {
+            const iosHotfix = iosVersion.version.hotfix || 0;
+            const androidHotfix = androidVersion.version.hotfix || 0;
+            hotfixInSync = iosHotfix === androidHotfix;
+        }
+        if (!allVersionsInSync || !hotfixInSync) {
+            consola.error('Versions are not synchronized across platforms:');
             versions.forEach((pv) => {
-                consola.log(`  ${pv.platform}: ${pv.source}`);
+                const versionStr = versionToString(pv.version);
+                const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
+                consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr} (${pv.source})`);
             });
+            throw new CliError('Versions are not synchronized across platforms');
         }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
-        }
+        const versionStr = versionToString(firstVersion);
+        // Show hotfix if iOS or Android has one
+        const platformWithHotfix = versions.find((pv) => pv.platform !== 'web' && pv.version.hotfix && pv.version.hotfix > 0);
+        const hotfixStr = platformWithHotfix ? ` (hotfix: ${platformWithHotfix.version.hotfix})` : '';
+        consola.success(`Version: ${versionStr}${hotfixStr}`);
+        versions.forEach((pv) => {
+            consola.log(`  ${pv.platform}: ${pv.source}`);
+        });
     },
 });

package/dist/commands/mutate/version/get.test.js

@@ -0,0 +1,85 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import getCommand from './get.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:get', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should display synchronized versions across all platforms', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+            {
+                platform: 'android',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
+                source: 'android/app/build.gradle',
+            },
+            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
+        ];
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        await getCommand.action({}, undefined);
+        expect(mockConsola.success).toHaveBeenCalledWith('Version: 1.2.3');
+        expect(mockConsola.log).toHaveBeenCalledWith('  ios: ios/App/App.xcodeproj/project.pbxproj');
+        expect(mockConsola.log).toHaveBeenCalledWith('  android: android/app/build.gradle');
+        expect(mockConsola.log).toHaveBeenCalledWith('  web: package.json');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should display hotfix when iOS/Android have one', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+            {
+                platform: 'android',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
+                source: 'android/app/build.gradle',
+            },
+            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
+        ];
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        await getCommand.action({}, undefined);
+        expect(mockConsola.success).toHaveBeenCalledWith('Version: 1.2.3 (hotfix: 5)');
+    });
+    it('should error when versions are not synchronized', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+            {
+                platform: 'android',
+                version: { major: 1, minor: 2, patch: 4, hotfix: 0 },
+                source: 'android/app/build.gradle',
+            },
+            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
+        ];
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        await expect(getCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(getCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
+        expect(mockConsola.error).toHaveBeenCalledWith('Versions are not synchronized across platforms:');
+        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3 (ios/App/App.xcodeproj/project.pbxproj)');
+        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.2.4 (android/app/build.gradle)');
+        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.3 (package.json)');
+    });
+    it('should error when no platform versions found', async () => {
+        mockVersionService.getAllVersions.mockResolvedValue([]);
+        await expect(getCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(getCommand.action({}, undefined)).rejects.toThrow('No platform versions found');
+    });
+});

package/dist/commands/mutate/version/hotfix.js

@@ -1,23 +1,22 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { incrementHotfix, versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
 export default defineCommand({
     description: 'Increment the hotfix version of the app in all relevant files',
     action: async () => {
-        try {
-            const currentVersion = await versionService.ensureVersionsInSync();
-            const newVersion = incrementHotfix(currentVersion);
-            const versionStr = versionToString(currentVersion);
-            const currentHotfix = currentVersion.hotfix || 0;
-            const newHotfix = newVersion.hotfix || 0;
-            consola.info(`Incrementing hotfix for version ${versionStr} (${currentHotfix} -> ${newHotfix})...`);
-            await versionService.setVersion(newVersion);
-            consola.success(`Hotfix incremented for version ${versionStr} (now ${newHotfix})`);
-        }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
+        const currentVersion = await versionService.ensureVersionsInSync();
+        // Check for hotfix version limit
+        const currentHotfix = currentVersion.hotfix || 0;
+        if (currentHotfix >= 99) {
+            throw new CliError('Cannot increment hotfix version: would exceed maximum value of 99');
         }
+        const newVersion = incrementHotfix(currentVersion);
+        const versionStr = versionToString(currentVersion);
+        const newHotfix = newVersion.hotfix || 0;
+        consola.info(`Incrementing hotfix for version ${versionStr} (${currentHotfix} -> ${newHotfix})...`);
+        await versionService.setVersion(newVersion);
+        consola.success(`Hotfix incremented for version ${versionStr} (now ${newHotfix})`);
     },
 });

package/dist/commands/mutate/version/hotfix.test.js

@@ -0,0 +1,49 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import hotfixCommand from './hotfix.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:hotfix', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should increment hotfix version from 0', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await hotfixCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing hotfix for version 1.2.3 (0 -> 1)...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3, hotfix: 1 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Hotfix incremented for version 1.2.3 (now 1)');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should increment existing hotfix version', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await hotfixCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing hotfix for version 1.2.3 (5 -> 6)...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3, hotfix: 6 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Hotfix incremented for version 1.2.3 (now 6)');
+    });
+    it('should handle maximum hotfix version limit', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 99 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow('Cannot increment hotfix version: would exceed maximum value of 99');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should handle hotfix sync errors between iOS and Android', async () => {
+        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Hotfix versions are not synchronized between iOS and Android'));
+        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow('Hotfix versions are not synchronized between iOS and Android');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/mutate/version/major.js

@@ -5,16 +5,10 @@ import consola from 'consola';
 export default defineCommand({
     description: 'Increment the major version of the app in all relevant files',
     action: async () => {
-        try {
-            const currentVersion = await versionService.ensureVersionsInSync();
-            const newVersion = incrementMajor(currentVersion);
-            consola.info(`Incrementing major version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-            await versionService.setVersion(newVersion);
-            consola.success(`Major version incremented to ${versionToString(newVersion)}`);
-        }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
-        }
+        const currentVersion = await versionService.ensureVersionsInSync();
+        const newVersion = incrementMajor(currentVersion);
+        consola.info(`Incrementing major version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
+        await versionService.setVersion(newVersion);
+        consola.success(`Major version incremented to ${versionToString(newVersion)}`);
     },
 });

package/dist/commands/mutate/version/major.test.js

@@ -0,0 +1,49 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import majorCommand from './major.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:major', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should increment major version successfully', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await majorCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing major version from 1.2.3 to 2.0.0...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 2, minor: 0, patch: 0 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Major version incremented to 2.0.0');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should handle large major versions', async () => {
+        const currentVersion = { major: 999, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await majorCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing major version from 999.2.3 to 1000.0.0...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1000, minor: 0, patch: 0 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Major version incremented to 1000.0.0');
+    });
+    it('should handle version sync errors', async () => {
+        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
+        await expect(majorCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should handle service errors during set', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockRejectedValue(new Error('Failed to update version'));
+        await expect(majorCommand.action({}, undefined)).rejects.toThrow('Failed to update version');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 2, minor: 0, patch: 0 });
+    });
+});

package/dist/commands/mutate/version/minor.js

@@ -1,20 +1,19 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { incrementMinor, versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
 export default defineCommand({
     description: 'Increment the minor version of the app in all relevant files',
     action: async () => {
-        try {
-            const currentVersion = await versionService.ensureVersionsInSync();
-            const newVersion = incrementMinor(currentVersion);
-            consola.info(`Incrementing minor version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-            await versionService.setVersion(newVersion);
-            consola.success(`Minor version incremented to ${versionToString(newVersion)}`);
-        }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
+        const currentVersion = await versionService.ensureVersionsInSync();
+        // Check for minor version limit
+        if (currentVersion.minor >= 999) {
+            throw new CliError('Cannot increment minor version: would exceed maximum value of 999');
         }
+        const newVersion = incrementMinor(currentVersion);
+        consola.info(`Incrementing minor version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
+        await versionService.setVersion(newVersion);
+        consola.success(`Minor version incremented to ${versionToString(newVersion)}`);
     },
 });

package/dist/commands/mutate/version/minor.test.js

@@ -0,0 +1,48 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import minorCommand from './minor.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:minor', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should increment minor version successfully', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await minorCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing minor version from 1.2.3 to 1.3.0...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 3, patch: 0 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Minor version incremented to 1.3.0');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should handle maximum minor version limit', async () => {
+        const currentVersion = { major: 1, minor: 999, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        await expect(minorCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(minorCommand.action({}, undefined)).rejects.toThrow('Cannot increment minor version: would exceed maximum value of 999');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should reset patch and hotfix when incrementing minor', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 5, hotfix: 3 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await minorCommand.action({}, undefined);
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 3, patch: 0 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Minor version incremented to 1.3.0');
+    });
+    it('should handle version sync errors', async () => {
+        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
+        await expect(minorCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/mutate/version/patch.js

@@ -1,20 +1,19 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { incrementPatch, versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
 export default defineCommand({
     description: 'Increment the patch version of the app in all relevant files',
     action: async () => {
-        try {
-            const currentVersion = await versionService.ensureVersionsInSync();
-            const newVersion = incrementPatch(currentVersion);
-            consola.info(`Incrementing patch version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-            await versionService.setVersion(newVersion);
-            consola.success(`Patch version incremented to ${versionToString(newVersion)}`);
-        }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
+        const currentVersion = await versionService.ensureVersionsInSync();
+        // Check for patch version limit
+        if (currentVersion.patch >= 99) {
+            throw new CliError('Cannot increment patch version: would exceed maximum value of 99');
         }
+        const newVersion = incrementPatch(currentVersion);
+        consola.info(`Incrementing patch version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
+        await versionService.setVersion(newVersion);
+        consola.success(`Patch version incremented to ${versionToString(newVersion)}`);
     },
 });

package/dist/commands/mutate/version/patch.test.js

@@ -0,0 +1,48 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import patchCommand from './patch.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:patch', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should increment patch version successfully', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await patchCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing patch version from 1.2.3 to 1.2.4...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 4 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Patch version incremented to 1.2.4');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should handle maximum patch version limit', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 99, hotfix: 0 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        await expect(patchCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(patchCommand.action({}, undefined)).rejects.toThrow('Cannot increment patch version: would exceed maximum value of 99');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should reset hotfix when incrementing patch', async () => {
+        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
+        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await patchCommand.action({}, undefined);
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 4 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Patch version incremented to 1.2.4');
+    });
+    it('should handle version sync errors', async () => {
+        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
+        await expect(patchCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/mutate/version/set.js

@@ -1,4 +1,5 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { parseVersion, versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
@@ -7,15 +8,15 @@ export default defineCommand({
     description: 'Set the version of the app in all relevant files',
     args: z.tuple([z.string().describe('Version')]),
     action: async (_options, args) => {
+        let version;
         try {
-            const version = parseVersion(args[0]);
-            consola.info(`Setting version to ${versionToString(version)}...`);
-            await versionService.setVersion(version);
-            consola.success(`Version set to ${versionToString(version)}`);
+            version = parseVersion(args[0]);
         }
         catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
+            throw new CliError("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
         }
+        consola.info(`Setting version to ${versionToString(version)}...`);
+        await versionService.setVersion(version);
+        consola.success(`Version set to ${versionToString(version)}`);
     },
 });

package/dist/commands/mutate/version/set.test.js

@@ -0,0 +1,41 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import setCommand from './set.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:set', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should set a valid version', async () => {
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await setCommand.action({}, ['1.2.3']);
+        expect(mockConsola.info).toHaveBeenCalledWith('Setting version to 1.2.3...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3 });
+        expect(mockConsola.success).toHaveBeenCalledWith('Version set to 1.2.3');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should handle invalid version format', async () => {
+        await expect(setCommand.action({}, ['1.2'])).rejects.toThrow(CliError);
+        await expect(setCommand.action({}, ['1.2'])).rejects.toThrow("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should handle non-numeric version parts', async () => {
+        await expect(setCommand.action({}, ['1.2.abc'])).rejects.toThrow(CliError);
+        await expect(setCommand.action({}, ['1.2.abc'])).rejects.toThrow("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should handle service errors', async () => {
+        mockVersionService.setVersion.mockRejectedValue(new Error('Failed to set version'));
+        await expect(setCommand.action({}, ['1.2.3'])).rejects.toThrow('Failed to set version');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3 });
+    });
+});

package/dist/commands/mutate/version/sync.js

@@ -1,32 +1,26 @@
 import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
 import { versionToString } from '../../../utils/version.js';
 import { defineCommand } from '@robingenz/zli';
 import consola from 'consola';
 export default defineCommand({
     description: 'Set the highest version number among all platforms in all relevant files',
     action: async () => {
-        try {
-            const versions = await versionService.getAllVersions();
-            if (versions.length === 0) {
-                consola.error('No platform versions found');
-                process.exit(1);
-            }
-            const highestVersion = await versionService.getHighestVersion();
-            consola.info('Current versions:');
-            versions.forEach((pv) => {
-                const versionStr = versionToString(pv.version);
-                const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
-                consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr}`);
-            });
-            const highestVersionStr = versionToString(highestVersion);
-            const hotfixStr = highestVersion.hotfix ? ` (hotfix: ${highestVersion.hotfix})` : '';
-            consola.info(`Syncing all platforms to highest version: ${highestVersionStr}${hotfixStr}...`);
-            await versionService.setVersion(highestVersion);
-            consola.success(`All platforms synced to version ${highestVersionStr}${hotfixStr}`);
-        }
-        catch (error) {
-            consola.error(error instanceof Error ? error.message : String(error));
-            process.exit(1);
+        const versions = await versionService.getAllVersions();
+        if (versions.length === 0) {
+            throw new CliError('No platform versions found');
         }
+        const highestVersion = await versionService.getHighestVersion();
+        consola.info('Current versions:');
+        versions.forEach((pv) => {
+            const versionStr = versionToString(pv.version);
+            const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
+            consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr}`);
+        });
+        const highestVersionStr = versionToString(highestVersion);
+        const hotfixStr = highestVersion.hotfix ? ` (hotfix: ${highestVersion.hotfix})` : '';
+        consola.info(`Syncing all platforms to highest version: ${highestVersionStr}${hotfixStr}...`);
+        await versionService.setVersion(highestVersion);
+        consola.success(`All platforms synced to version ${highestVersionStr}${hotfixStr}`);
     },
 });

package/dist/commands/mutate/version/sync.test.js

@@ -0,0 +1,90 @@
+import versionService from '../../../services/mutate/version.js';
+import { CliError } from '../../../utils/error.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import syncCommand from './sync.js';
+vi.mock('consola');
+vi.mock('@/services/mutate/version.js');
+describe('mutate:version:sync', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockVersionService = vi.mocked(versionService);
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should sync to highest version across platforms', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+            {
+                platform: 'android',
+                version: { major: 1, minor: 3, patch: 0, hotfix: 0 },
+                source: 'android/app/build.gradle',
+            },
+            { platform: 'web', version: { major: 1, minor: 2, patch: 4 }, source: 'package.json' },
+        ];
+        const highestVersion = { major: 1, minor: 3, patch: 0, hotfix: 0 };
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        mockVersionService.getHighestVersion.mockResolvedValue(highestVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await syncCommand.action({}, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith('Current versions:');
+        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3');
+        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.3.0');
+        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.4');
+        expect(mockConsola.info).toHaveBeenCalledWith('Syncing all platforms to highest version: 1.3.0...');
+        expect(mockVersionService.setVersion).toHaveBeenCalledWith(highestVersion);
+        expect(mockConsola.success).toHaveBeenCalledWith('All platforms synced to version 1.3.0');
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('should sync including hotfix for iOS/Android', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+            {
+                platform: 'android',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
+                source: 'android/app/build.gradle',
+            },
+            { platform: 'web', version: { major: 1, minor: 2, patch: 2 }, source: 'package.json' },
+        ];
+        const highestVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        mockVersionService.getHighestVersion.mockResolvedValue(highestVersion);
+        mockVersionService.setVersion.mockResolvedValue(undefined);
+        await syncCommand.action({}, undefined);
+        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3 (hotfix: 5)');
+        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.2.3 (hotfix: 5)');
+        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.2');
+        expect(mockConsola.info).toHaveBeenCalledWith('Syncing all platforms to highest version: 1.2.3 (hotfix: 5)...');
+        expect(mockConsola.success).toHaveBeenCalledWith('All platforms synced to version 1.2.3 (hotfix: 5)');
+    });
+    it('should handle no platform versions found', async () => {
+        mockVersionService.getAllVersions.mockResolvedValue([]);
+        await expect(syncCommand.action({}, undefined)).rejects.toThrow(CliError);
+        await expect(syncCommand.action({}, undefined)).rejects.toThrow('No platform versions found');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+    it('should handle service errors', async () => {
+        const mockVersions = [
+            {
+                platform: 'ios',
+                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
+                source: 'ios/App/App.xcodeproj/project.pbxproj',
+            },
+        ];
+        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
+        mockVersionService.getHighestVersion.mockRejectedValue(new Error('Failed to determine highest version'));
+        await expect(syncCommand.action({}, undefined)).rejects.toThrow('Failed to determine highest version');
+        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
+    });
+});

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import configService from './services/config.js';
 import updateService from './services/update.js';
-import { getMessageFromUnknownError } from './utils/error.js';
+import { CliError, getMessageFromUnknownError } from './utils/error.js';
 import { defineConfig, processConfig, ZliError } from '@robingenz/zli';
 import * as Sentry from '@sentry/node';
 import { AxiosError } from 'axios';
 import consola from 'consola';
-import { ZodError } from 'zod';
 import { createRequire } from 'module';
+import { ZodError } from 'zod';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const config = defineConfig({
@@ -44,10 +44,13 @@ const config = defineConfig({
     },
 });
 const captureException = async (error) => {
-    // Ignore errors from the CLI itself (e.g. "No command found.")
+    // Ignore expected CLI errors (e.g. "No command found.")
     if (error instanceof ZliError) {
         return;
     }
+    if (error instanceof CliError) {
+        return;
+    }
     // Ignore validation errors
     if (error instanceof ZodError) {
         return;

package/dist/services/mutate/version.js

@@ -1,3 +1,4 @@
+import { CliError } from '../../utils/error.js';
 import { compareVersions, parseBuildNumber, parseVersion, versionToBuildNumber, versionToString, } from '../../utils/version.js';
 import { MobileProject, Logger } from '@trapezedev/project';
 import { existsSync, readFileSync } from 'fs';
@@ -165,7 +166,7 @@ export class VersionService {
         const versions = await this.getAllVersions();
         const firstVersion = versions && versions[0] ? versions[0].version : null;
         if (!firstVersion) {
-            throw new Error('No platform versions found');
+            throw new CliError('No platform versions found');
         }
         // Check major.minor.patch synchronization for all platforms
         const allVersionsInSync = versions.every((pv) => pv.version.major === firstVersion.major &&
@@ -177,7 +178,7 @@ export class VersionService {
                 const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
                 return `${pv.platform}: ${versionStr}${hotfixStr} (${pv.source})`;
             });
-            throw new Error(`Versions are not synchronized across platforms:\n${versionStrings.join('\n')}`);
+            throw new CliError(`Versions are not synchronized across platforms:\n${versionStrings.join('\n')}`);
         }
         // Check hotfix synchronization between iOS and Android only
         const iosVersion = versions.find((pv) => pv.platform === 'ios');
@@ -186,7 +187,7 @@ export class VersionService {
             const iosHotfix = iosVersion.version.hotfix || 0;
             const androidHotfix = androidVersion.version.hotfix || 0;
             if (iosHotfix !== androidHotfix) {
-                throw new Error(`Hotfix versions are not synchronized between iOS and Android:\n` +
+                throw new CliError(`Hotfix versions are not synchronized between iOS and Android:\n` +
                     `iOS: ${versionToString(iosVersion.version)} (hotfix: ${iosHotfix})\n` +
                     `Android: ${versionToString(androidVersion.version)} (hotfix: ${androidHotfix})`);
             }
@@ -198,7 +199,7 @@ export class VersionService {
     async getHighestVersion() {
         const versions = await this.getAllVersions();
         if (versions.length === 0) {
-            throw new Error('No platform versions found');
+            throw new CliError('No platform versions found');
         }
         let highest = versions[0];
         for (const current of versions) {

package/dist/utils/error.js

@@ -1,8 +1,17 @@
 import { AxiosError } from 'axios';
 import { ZodError } from 'zod';
+export class CliError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliError';
+    }
+}
 export const getMessageFromUnknownError = (error) => {
     let message = 'An unknown error has occurred.';
-    if (error instanceof AxiosError) {
+    if (error instanceof CliError) {
+        message = error.message;
+    }
+    else if (error instanceof AxiosError) {
         message = getErrorMessageFromAxiosError(error);
     }
     else if (error instanceof ZodError) {

package/dist/utils/error.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { CliError, getMessageFromUnknownError } from './error.js';
+describe('CliError', () => {
+    it('should be an instance of Error', () => {
+        const error = new CliError('Test error');
+        expect(error).toBeInstanceOf(Error);
+        expect(error).toBeInstanceOf(CliError);
+    });
+    it('should have the correct name', () => {
+        const error = new CliError('Test error');
+        expect(error.name).toBe('CliError');
+    });
+    it('should have the correct message', () => {
+        const message = 'This is a test error message';
+        const error = new CliError(message);
+        expect(error.message).toBe(message);
+    });
+});
+describe('getMessageFromUnknownError', () => {
+    it('should handle CliError correctly', () => {
+        const message = 'This is a CLI error';
+        const error = new CliError(message);
+        expect(getMessageFromUnknownError(error)).toBe(message);
+    });
+    it('should handle regular Error', () => {
+        const message = 'This is a regular error';
+        const error = new Error(message);
+        expect(getMessageFromUnknownError(error)).toBe(message);
+    });
+    it('should handle unknown error types', () => {
+        expect(getMessageFromUnknownError('string error')).toBe('An unknown error has occurred.');
+        expect(getMessageFromUnknownError(123)).toBe('An unknown error has occurred.');
+        expect(getMessageFromUnknownError(null)).toBe('An unknown error has occurred.');
+        expect(getMessageFromUnknownError(undefined)).toBe('An unknown error has occurred.');
+    });
+});

package/package.json

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