@capawesome/cli 2.1.4-dev.6aa4113.1756747591 → 2.1.4-dev.6aa4113.1756747593

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

@@ -12,23 +12,34 @@ export default defineCommand({
                 process.exit(1);
             }
             const firstVersion = versions[0].version;
-            const allInSync = versions.every((pv) => {
+            // 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 &&
-                    pv.version.hotfix === firstVersion.hotfix);
+                    pv.version.patch === firstVersion.patch);
             });
-            if (!allInSync) {
+            // 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.version.hotfix > 0 ? ` (hotfix: ${pv.version.hotfix})` : '';
+                    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);
-            const hotfixStr = firstVersion.hotfix > 0 ? ` (hotfix: ${firstVersion.hotfix})` : '';
+            // 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/hotfix.js

@@ -8,12 +8,12 @@ export default defineCommand({
         try {
             const currentVersion = await versionService.ensureVersionsInSync();
             const newVersion = incrementHotfix(currentVersion);
-            const currentVersionStr = versionToString(currentVersion);
-            const newVersionStr = versionToString(newVersion);
-            const hotfixInfo = `(hotfix: ${currentVersion.hotfix} -> ${newVersion.hotfix})`;
-            consola.info(`Incrementing hotfix version from ${currentVersionStr} to ${newVersionStr} ${hotfixInfo}...`);
+            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 version incremented to ${newVersionStr} (hotfix: ${newVersion.hotfix})`);
+            consola.success(`Hotfix incremented for version ${versionStr} (now ${newHotfix})`);
         }
         catch (error) {
             consola.error(error instanceof Error ? error.message : String(error));

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

@@ -5,12 +5,10 @@ import consola from 'consola';
 import { z } from 'zod';
 export default defineCommand({
     description: 'Set the version of the app in all relevant files',
-    args: z.object({
-        version: z.string(),
-    }),
+    args: z.tuple([z.string().describe('Version')]),
     action: async (_options, args) => {
         try {
-            const version = parseVersion(args.version);
+            const version = parseVersion(args[0]);
             consola.info(`Setting version to ${versionToString(version)}...`);
             await versionService.setVersion(version);
             consola.success(`Version set to ${versionToString(version)}`);

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

@@ -15,11 +15,11 @@ export default defineCommand({
             consola.info('Current versions:');
             versions.forEach((pv) => {
                 const versionStr = versionToString(pv.version);
-                const hotfixStr = pv.version.hotfix > 0 ? ` (hotfix: ${pv.version.hotfix})` : '';
+                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 > 0 ? ` (hotfix: ${highestVersion.hotfix})` : '';
+            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/services/mutate/version.js

@@ -1,7 +1,7 @@
+import { compareVersions, parseBuildNumber, parseVersion, versionToBuildNumber, versionToString, } from '../../utils/version.js';
 import { MobileProject } from '@trapezedev/project';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { compareVersions, parseBuildNumber, parseVersion, versionToBuildNumber, versionToString, versionsEqual, } from '../../utils/version.js';
 export class VersionService {
     projectPath;
     constructor(projectPath = process.cwd()) {
@@ -38,7 +38,7 @@ export class VersionService {
             if (!project.ios) {
                 return null;
             }
-            const iosProject = await project.ios.getPbxProject();
+            const iosProject = project.ios.getPbxProject();
             if (!iosProject) {
                 return null;
             }
@@ -97,6 +97,7 @@ export class VersionService {
             if (!packageJson.version) {
                 return null;
             }
+            // Web only has version string, no build number (hotfix will always be 0)
             const version = parseVersion(packageJson.version);
             return {
                 platform: 'web',
@@ -148,6 +149,7 @@ export class VersionService {
         if (existsSync(packageJsonPath)) {
             const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             packageJson.version = versionString;
+            // Web only stores version string, not build number
             const fs = await import('fs/promises');
             await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
         }
@@ -155,16 +157,37 @@ export class VersionService {
     }
     async ensureVersionsInSync() {
         const versions = await this.getAllVersions();
-        if (versions.length === 0) {
+        const firstVersion = versions && versions[0] ? versions[0].version : null;
+        if (!firstVersion) {
             throw new Error('No platform versions found');
         }
-        const firstVersion = versions[0].version;
-        const allInSync = versions.every((pv) => versionsEqual(pv.version, firstVersion));
-        if (!allInSync) {
-            const versionStrings = versions.map((pv) => `${pv.platform}: ${versionToString(pv.version)} (${pv.source})`);
+        // Check major.minor.patch synchronization for all platforms
+        const allVersionsInSync = versions.every((pv) => pv.version.major === firstVersion.major &&
+            pv.version.minor === firstVersion.minor &&
+            pv.version.patch === firstVersion.patch);
+        if (!allVersionsInSync) {
+            const versionStrings = versions.map((pv) => {
+                const versionStr = versionToString(pv.version);
+                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')}`);
         }
-        return firstVersion;
+        // Check hotfix synchronization between iOS and Android only
+        const iosVersion = versions.find((pv) => pv.platform === 'ios');
+        const androidVersion = versions.find((pv) => pv.platform === 'android');
+        if (iosVersion && androidVersion) {
+            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` +
+                    `iOS: ${versionToString(iosVersion.version)} (hotfix: ${iosHotfix})\n` +
+                    `Android: ${versionToString(androidVersion.version)} (hotfix: ${androidHotfix})`);
+            }
+        }
+        // Return version with hotfix from iOS or Android if available
+        const versionWithHotfix = versions.find((pv) => pv.platform !== 'web' && pv.version.hotfix && pv.version.hotfix > 0);
+        return versionWithHotfix ? versionWithHotfix.version : firstVersion;
     }
     async getHighestVersion() {
         const versions = await this.getAllVersions();

package/dist/utils/version.js

@@ -12,7 +12,7 @@ export const parseVersion = (versionString) => {
     if (major < 0 || minor < 0 || patch < 0) {
         throw new Error(`Invalid version format: ${versionString}. Version parts must be non-negative.`);
     }
-    return { major, minor, patch, hotfix: 0 };
+    return { major, minor, patch };
 };
 export const parseBuildNumber = (buildNumber) => {
     const buildStr = buildNumber.toString();
@@ -37,38 +37,39 @@ export const versionToBuildNumber = (version) => {
     const majorStr = version.major.toString();
     const minor = version.minor.toString().padStart(3, '0');
     const patch = version.patch.toString().padStart(2, '0');
-    const hotfix = version.hotfix.toString().padStart(2, '0');
+    const hotfix = (version.hotfix || 0).toString().padStart(2, '0');
     if (version.minor > 999) {
         throw new Error(`Minor version ${version.minor} exceeds maximum value of 999`);
     }
     if (version.patch > 99) {
         throw new Error(`Patch version ${version.patch} exceeds maximum value of 99`);
     }
-    if (version.hotfix > 99) {
+    if (version.hotfix && version.hotfix > 99) {
         throw new Error(`Hotfix version ${version.hotfix} exceeds maximum value of 99`);
     }
     return parseInt(`${majorStr}${minor}${patch}${hotfix}`, 10);
 };
 export const incrementMajor = (version) => {
     const newMajor = version.major + 1;
-    return { major: newMajor, minor: 0, patch: 0, hotfix: 0 };
+    return { major: newMajor, minor: 0, patch: 0 };
 };
 export const incrementMinor = (version) => {
     const newMinor = version.minor + 1;
     if (newMinor > 999) {
         throw new Error(`Cannot increment minor version: would exceed maximum value of 999`);
     }
-    return { ...version, minor: newMinor, patch: 0, hotfix: 0 };
+    return { major: version.major, minor: newMinor, patch: 0 };
 };
 export const incrementPatch = (version) => {
     const newPatch = version.patch + 1;
     if (newPatch > 99) {
         throw new Error(`Cannot increment patch version: would exceed maximum value of 99`);
     }
-    return { ...version, patch: newPatch, hotfix: 0 };
+    return { major: version.major, minor: version.minor, patch: newPatch };
 };
 export const incrementHotfix = (version) => {
-    const newHotfix = version.hotfix + 1;
+    const currentHotfix = version.hotfix || 0;
+    const newHotfix = currentHotfix + 1;
     if (newHotfix > 99) {
         throw new Error(`Cannot increment hotfix version: would exceed maximum value of 99`);
     }
@@ -81,10 +82,15 @@ export const compareVersions = (v1, v2) => {
         return v1.minor - v2.minor;
     if (v1.patch !== v2.patch)
         return v1.patch - v2.patch;
-    if (v1.hotfix !== v2.hotfix)
-        return v1.hotfix - v2.hotfix;
+    const h1 = v1.hotfix || 0;
+    const h2 = v2.hotfix || 0;
+    if (h1 !== h2)
+        return h1 - h2;
     return 0;
 };
-export const versionsEqual = (v1, v2) => {
+export const versionsEqual = (v1, v2, ignoreHotfix = false) => {
+    if (ignoreHotfix) {
+        return v1.major === v2.major && v1.minor === v2.minor && v1.patch === v2.patch;
+    }
     return compareVersions(v1, v2) === 0;
 };

package/package.json

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