@capawesome/cli 4.18.3 → 4.19.0

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

@@ -0,0 +1,340 @@
+import { parseAppflowExport } from '../utils/appflow-export.js';
+import { UserError } from '../utils/error.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+describe('appflow-export', () => {
+    let exportDirectory;
+    beforeEach(() => {
+        exportDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'appflow-export-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(exportDirectory, { recursive: true, force: true });
+    });
+    const writeAppFiles = (appFolder, files) => {
+        for (const [fileName, content] of Object.entries(files)) {
+            const filePath = path.join(exportDirectory, 'apps', appFolder, fileName);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            if (typeof content === 'string' || Buffer.isBuffer(content)) {
+                fs.writeFileSync(filePath, content);
+            }
+            else {
+                fs.writeFileSync(filePath, JSON.stringify(content));
+            }
+        }
+    };
+    it('should throw a user error if the export does not contain an apps directory', async () => {
+        await expect(parseAppflowExport(exportDirectory)).rejects.toThrow(UserError);
+    });
+    it('should parse a fully configured app', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+            'repo-association.json': {
+                gitProvider: 'github',
+                gitUsername: 'robingenz',
+                cloneUrl: 'https://github.com/robingenz/appflow-export-test.git',
+            },
+            'environments.json': [
+                { id: 33513, name: 'Development', vars: { DEBUG: 'true' }, secrets: null },
+                { id: 33515, name: 'Production', vars: {}, secrets: { API_KEY: 'secret' } },
+            ],
+            'live-update-channels.json': [
+                { id: 'd33204c6', name: 'Production' },
+                { id: '1e168146', name: 'Staging' },
+            ],
+            'native-configs.json': [
+                {
+                    id: 41087,
+                    name: 'Development',
+                    configs: {
+                        base: { name: 'My App (Dev)', bundle_id: 'dev.robingenz.app.dev' },
+                        ionic: { channel_name: 'Development', update_method: 'background' },
+                    },
+                },
+                { id: 41089, name: 'Barebones', configs: { base: { bundle_id: 'dev.robingenz.app.bare' } } },
+            ],
+            'native-build-automations.json': [
+                {
+                    name: 'Android Release',
+                    gitBranch: 'main',
+                    type: 'package',
+                    platform: 'android',
+                    buildType: 'release',
+                    environmentId: 33515,
+                    webhook: 'https://example.com/webhook',
+                    automationEnabled: true,
+                    nativeConfigId: 41087,
+                    signingCertificateId: 154267,
+                    destinationId: null,
+                },
+                {
+                    name: 'iOS Store',
+                    gitBranch: 'main',
+                    type: 'package',
+                    platform: 'ios',
+                    buildType: 'development',
+                    environmentId: 99999,
+                    webhook: null,
+                    automationEnabled: false,
+                    nativeConfigId: null,
+                    signingCertificateId: null,
+                    destinationId: null,
+                },
+            ],
+            'web-build-automations.json': [
+                {
+                    name: 'Web Prod',
+                    gitBranch: 'main',
+                    type: 'deploy',
+                    platform: 'web-deploy',
+                    environmentId: 33515,
+                    webhook: null,
+                    automationEnabled: true,
+                    channelIds: ['1e168146', 'd33204c6'],
+                    webPreviewEnabled: true,
+                },
+            ],
+            'signing-certificates/android/Debug-154267/android-signing-certificate.json': {
+                id: 154267,
+                name: 'Debug',
+                keystoreFile: 'keystore.jks',
+                keystorePassword: 'test1234',
+                keyAlias: 'key',
+                keyPassword: 'test1234',
+            },
+            'signing-certificates/android/Debug-154267/keystore.jks': Buffer.from('keystore'),
+            'signing-certificates/ios/Dev-154266/ios-signing-certificate.json': {
+                id: 154266,
+                name: 'Dev',
+                p12File: 'ios-certificate.p12',
+                p12Password: '123456',
+                provisioningProfiles: ['Test.mobileprovision'],
+            },
+            'signing-certificates/ios/Dev-154266/ios-certificate.p12': Buffer.from('p12'),
+            'signing-certificates/ios/Dev-154266/Test.mobileprovision': Buffer.from('profile'),
+            'store-destinations/android/Prod-27890/play-store-destination.json': {
+                id: 27890,
+                name: 'Prod',
+                artifactType: 'aab',
+                packageName: 'dev.robingenz.app',
+                track: 'internal',
+                releaseStatus: 'completed',
+            },
+            'store-destinations/android/Prod-27890/json-key.json': { type: 'service_account' },
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(skippedApps).toEqual([]);
+        expect(apps).toHaveLength(1);
+        const app = apps[0];
+        expect(app.sourceId).toBe('6668c18c');
+        expect(app.sourceName).toBe('My App');
+        expect(app.type).toBe('capacitor');
+        expect(app.repository).toEqual({
+            ownerSlug: 'robingenz',
+            provider: 'github',
+            repositorySlug: 'appflow-export-test',
+            projectSlug: undefined,
+        });
+        expect(app.environments).toEqual([
+            { name: 'Development', variables: [{ key: 'DEBUG', value: 'true' }], secrets: [] },
+            { name: 'Production', variables: [], secrets: [{ key: 'API_KEY', value: 'secret' }] },
+        ]);
+        expect(app.channels).toEqual(['Production', 'Staging']);
+        expect(app.configurations).toEqual([
+            { name: 'Development', displayName: 'My App (Dev)', packageName: 'dev.robingenz.app.dev' },
+            { name: 'Barebones', displayName: undefined, packageName: 'dev.robingenz.app.bare' },
+        ]);
+        expect(app.certificates).toHaveLength(2);
+        expect(app.certificates[0]).toMatchObject({
+            name: 'Debug',
+            platform: 'android',
+            password: 'test1234',
+            keyAlias: 'key',
+            keyPassword: 'test1234',
+        });
+        expect(app.certificates[1]).toMatchObject({ name: 'Dev', platform: 'ios', password: '123456' });
+        expect(app.certificates[1].provisioningProfilePaths).toHaveLength(1);
+        expect(app.destinations).toEqual([
+            {
+                name: 'Prod',
+                platform: 'android',
+                androidPackageName: 'dev.robingenz.app',
+                androidBuildArtifactType: 'aab',
+                androidReleaseStatus: 'completed',
+                googlePlayTrack: 'internal',
+                googleServiceAccountKeyPath: expect.stringContaining('json-key.json'),
+            },
+        ]);
+        expect(app.automations).toEqual([
+            {
+                name: 'Android Release',
+                platform: 'android',
+                triggerPattern: 'main',
+                buildType: 'release',
+                enabled: true,
+                appCertificateName: 'Debug',
+                appConfigurationName: 'Development',
+                appDestinationName: undefined,
+                appEnvironmentName: 'Production',
+            },
+            {
+                name: 'iOS Store',
+                platform: 'ios',
+                triggerPattern: 'main',
+                buildType: 'development',
+                enabled: false,
+                appCertificateName: undefined,
+                appConfigurationName: undefined,
+                appDestinationName: undefined,
+                appEnvironmentName: undefined,
+            },
+            {
+                name: 'Web Prod (Staging)',
+                platform: 'web',
+                triggerPattern: 'main',
+                enabled: true,
+                appChannelName: 'Staging',
+                appEnvironmentName: 'Production',
+            },
+            {
+                name: 'Web Prod (Production)',
+                platform: 'web',
+                triggerPattern: 'main',
+                enabled: true,
+                appChannelName: 'Production',
+                appEnvironmentName: 'Production',
+            },
+        ]);
+        expect(app.notes).toHaveLength(4);
+        expect(app.notes).toContainEqual(expect.stringContaining('webhook'));
+        expect(app.notes).toContainEqual(expect.stringContaining('unknown environment'));
+        expect(app.notes).toContainEqual(expect.stringContaining('web previews'));
+        expect(app.notes).toContainEqual(expect.stringContaining('Live Update plugin settings'));
+    });
+    it('should keep the ambiguous app type `ionic` as source app type', async () => {
+        writeAppFiles('Legacy App-11111111', {
+            'app-detail.json': { id: '11111111', name: 'Legacy App', appType: 'ionic' },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toHaveLength(1);
+        expect(apps[0].sourceAppType).toBe('ionic');
+        expect(apps[0].notes).toEqual([]);
+    });
+    it('should skip apps with an unsupported app type', async () => {
+        writeAppFiles('RN App-22222222', {
+            'app-detail.json': { id: '22222222', name: 'RN App', appType: 'react_native' },
+        });
+        writeAppFiles('Other App-33333333', {
+            'app-detail.json': { id: '33333333', name: 'Other App', appType: 'unknown' },
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toEqual([]);
+        expect(skippedApps).toContainEqual({
+            sourceId: '22222222',
+            sourceName: 'RN App',
+            reason: expect.stringContaining('react_native'),
+            retryLater: true,
+        });
+        expect(skippedApps).toContainEqual({
+            sourceId: '33333333',
+            sourceName: 'Other App',
+            reason: expect.stringContaining('unknown'),
+            retryLater: false,
+        });
+    });
+    it('should handle an empty repo association serialized as an array', async () => {
+        writeAppFiles('No Repo-44444444', {
+            'app-detail.json': { id: '44444444', name: 'No Repo', appType: 'capacitor' },
+            'repo-association.json': [],
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].repository).toBeNull();
+    });
+    it('should skip a signing certificate with a missing file', async () => {
+        writeAppFiles('Broken Cert-55555555', {
+            'app-detail.json': { id: '55555555', name: 'Broken Cert', appType: 'capacitor' },
+            'signing-certificates/android/Debug-1/android-signing-certificate.json': {
+                id: 1,
+                name: 'Debug',
+                keystoreFile: 'keystore.jks',
+                keystorePassword: 'test',
+                keyAlias: 'key',
+                keyPassword: 'test',
+            },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].certificates).toEqual([]);
+        expect(apps[0].notes).toContainEqual(expect.stringContaining('keystore.jks'));
+    });
+    it.each(['v2.0.0', 'v10.0.0'])('should warn about the unsupported export format version %s', async (version) => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+        });
+        fs.writeFileSync(path.join(exportDirectory, 'manifest.json'), JSON.stringify({ version }));
+        const { warnings } = await parseAppflowExport(exportDirectory);
+        expect(warnings).toEqual([expect.stringContaining(`\`${version}\``)]);
+    });
+    it('should not warn about a supported export format version', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+        });
+        fs.writeFileSync(path.join(exportDirectory, 'manifest.json'), JSON.stringify({ version: 'v1.0.0', exportedAt: '2026-08-24T15:07:00Z' }));
+        const { warnings } = await parseAppflowExport(exportDirectory);
+        expect(warnings).toEqual([]);
+    });
+    it('should not warn about a missing manifest', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+        });
+        const { warnings } = await parseAppflowExport(exportDirectory);
+        expect(warnings).toEqual([]);
+    });
+    it('should skip certificate files that resolve outside the export', async () => {
+        writeAppFiles('Evil-77777777', {
+            'app-detail.json': { id: '77777777', name: 'Evil', appType: 'capacitor' },
+            'signing-certificates/android/Debug-1/android-signing-certificate.json': {
+                id: 1,
+                name: 'Debug',
+                keystoreFile: '../../../outside.jks',
+                keystorePassword: 'test',
+                keyAlias: 'key',
+                keyPassword: 'test',
+            },
+            'signing-certificates/ios/Dev-2/ios-signing-certificate.json': {
+                id: 2,
+                name: 'Dev',
+                p12File: '/etc/hosts',
+                p12Password: 'test',
+                provisioningProfiles: [],
+            },
+            'signing-certificates/ios/Prod-3/ios-signing-certificate.json': {
+                id: 3,
+                name: 'Prod',
+                p12File: 'ios-certificate.p12',
+                p12Password: 'test',
+                provisioningProfiles: ['Test.mobileprovision', '../../../../etc/hosts'],
+            },
+            'signing-certificates/ios/Prod-3/ios-certificate.p12': Buffer.from('p12'),
+            'signing-certificates/ios/Prod-3/Test.mobileprovision': Buffer.from('profile'),
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        const app = apps[0];
+        expect(app.certificates).toHaveLength(1);
+        expect(app.certificates[0].name).toBe('Prod');
+        expect(app.certificates[0].provisioningProfilePaths).toHaveLength(1);
+        expect(app.certificates[0].provisioningProfilePaths[0]).toContain('Test.mobileprovision');
+        expect(app.notes).toContainEqual(expect.stringContaining('`../../../outside.jks` is invalid'));
+        expect(app.notes).toContainEqual(expect.stringContaining('`/etc/hosts` is invalid'));
+        expect(app.notes).toContainEqual(expect.stringContaining('`../../../../etc/hosts`'));
+    });
+    it('should skip an app with an invalid app detail file', async () => {
+        writeAppFiles('Invalid-66666666', {
+            'app-detail.json': 'not json',
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toEqual([]);
+        expect(skippedApps).toHaveLength(1);
+        expect(skippedApps[0].retryLater).toBe(false);
+    });
+});

package/dist/utils/file.js

@@ -1,6 +1,16 @@
 import fs from 'fs';
 import mime from 'mime';
 import pathModule from 'path';
+import { createBufferFromPath } from './buffer.js';
+import { getCodeFromUnknownError, UserError } from './error.js';
+const concurrentModificationHint = 'Make sure that no other process (e.g. a build or file sync client) modifies the folder while the command is running.';
+const permissionHint = 'Make sure that you have permission to read the file.';
+const unreadableFileErrorHints = {
+    EACCES: permissionHint,
+    EBUSY: concurrentModificationHint,
+    ENOENT: concurrentModificationHint,
+    EPERM: permissionHint,
+};
 export const getFilesInDirectoryAndSubdirectories = async (path) => {
     const files = [];
     const walk = async (directory) => {
@@ -38,6 +48,23 @@ export const getFilesInDirectoryAndSubdirectories = async (path) => {
     await walk(path);
     return files;
 };
+/**
+ * Reads a file that was found by `getFilesInDirectoryAndSubdirectories`.
+ * Such files can vanish, get locked or become inaccessible in the meantime (e.g. by a running build or a file sync client).
+ */
+export const readFileFromDirectory = async (path) => {
+    try {
+        return await createBufferFromPath(path);
+    }
+    catch (error) {
+        const code = getCodeFromUnknownError(error);
+        const hint = code ? unreadableFileErrorHints[code] : undefined;
+        if (hint) {
+            throw new UserError(`The file could not be read: ${path}. ${hint}`);
+        }
+        throw error;
+    }
+};
 export const directoryContainsSymlinks = async (path) => {
     const dirEntries = await fs.promises.readdir(path, { withFileTypes: true, recursive: true }).catch(() => []);
     return dirEntries.some((dirEntry) => dirEntry.isSymbolicLink());

package/dist/utils/file.test.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import os from 'os';
+import pathModule from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { UserError } from './error.js';
+import { readFileFromDirectory } from './file.js';
+const { mockCreateBufferFromPath } = vi.hoisted(() => ({ mockCreateBufferFromPath: vi.fn() }));
+vi.mock('./buffer.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    mockCreateBufferFromPath.mockImplementation(actual.createBufferFromPath);
+    return { ...actual, createBufferFromPath: mockCreateBufferFromPath };
+});
+const createErrorWithCode = (code) => Object.assign(new Error(code), { code });
+describe('readFileFromDirectory', () => {
+    let directory;
+    beforeEach(() => {
+        directory = fs.mkdtempSync(pathModule.join(os.tmpdir(), 'file-'));
+    });
+    afterEach(() => {
+        fs.rmSync(directory, { force: true, recursive: true });
+    });
+    it('should read the file', async () => {
+        const path = pathModule.join(directory, 'index.html');
+        fs.writeFileSync(path, '<html></html>');
+        const buffer = await readFileFromDirectory(path);
+        expect(buffer.toString()).toBe('<html></html>');
+    });
+    it('should throw a user error if the file no longer exists', async () => {
+        const path = pathModule.join(directory, 'missing.png');
+        const promise = readFileFromDirectory(path);
+        await expect(promise).rejects.toThrow(UserError);
+        await expect(promise).rejects.toThrow(`The file could not be read: ${path}. Make sure that no other process`);
+    });
+    it('should throw a user error if the file is not readable', async () => {
+        const path = pathModule.join(directory, 'index.html');
+        mockCreateBufferFromPath.mockRejectedValueOnce(createErrorWithCode('EACCES'));
+        const promise = readFileFromDirectory(path);
+        await expect(promise).rejects.toThrow(UserError);
+        await expect(promise).rejects.toThrow(`The file could not be read: ${path}. Make sure that you have permission to read the file.`);
+    });
+    it('should rethrow errors that are not related to reading the file', async () => {
+        const error = createErrorWithCode('EISDIR');
+        mockCreateBufferFromPath.mockRejectedValueOnce(error);
+        await expect(readFileFromDirectory(pathModule.join(directory, 'assets'))).rejects.toBe(error);
+    });
+});

package/dist/utils/manifest.js

@@ -1,6 +1,5 @@
 import { MANIFEST_JSON_FILE_NAME } from '../config/index.js';
-import { createBufferFromPath } from './buffer.js';
-import { getFilesInDirectoryAndSubdirectories, writeFile } from './file.js';
+import { getFilesInDirectoryAndSubdirectories, readFileFromDirectory, writeFile } from './file.js';
 import { createHash } from './hash.js';
 const ignoreFiles = ['.DS_Store', MANIFEST_JSON_FILE_NAME];
 export const generateManifestJson = async (path) => {
@@ -9,7 +8,7 @@ export const generateManifestJson = async (path) => {
     const files = await getFilesInDirectoryAndSubdirectories(path);
     // Iterate over each file
     for (const [index, file] of files.entries()) {
-        const fileBuffer = await createBufferFromPath(file.path);
+        const fileBuffer = await readFileFromDirectory(file.path);
         const checksum = await createHash(fileBuffer);
         const sizeInBytes = fileBuffer.byteLength;
         // Skip ignored files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "4.18.3",
+  "version": "4.19.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {
@@ -58,7 +58,7 @@
     "@clack/prompts": "0.7.0",
     "@napi-rs/keyring": "1.3.0",
     "@sentry/node": "10.58.0",
-    "adm-zip": "0.6.0",
+    "adm-zip": "0.6.1",
     "axios": "1.18.1",
     "axios-retry": "4.5.0",
     "c12": "3.3.3",
@@ -81,14 +81,14 @@
     "@types/mime": "3.0.4",
     "@types/node": "24.2.1",
     "@types/semver": "7.5.8",
-    "@vitest/coverage-v8": "4.1.7",
-    "@vitest/ui": "4.1.7",
+    "@vitest/coverage-v8": "4.1.11",
+    "@vitest/ui": "4.1.11",
     "nock": "14.0.10",
     "prettier": "3.3.3",
     "rimraf": "6.0.1",
     "tsc-alias": "1.8.16",
     "typescript": "5.6.3",
-    "vitest": "4.1.7"
+    "vitest": "4.1.11"
   },
   "prettier": "@ionic/prettier-config"
 }