@capawesome/cli 4.18.3 → 4.19.0

package/dist/utils/appflow-export.js

@@ -0,0 +1,425 @@
+import { getMessageFromUnknownError, UserError } from '../utils/error.js';
+import { parseGitRemoteUrl } from '../utils/git.js';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+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'];
+const manifestSchema = z.object({
+    version: z.string().nullish(),
+});
+const appDetailSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    appType: z.string(),
+    latestBuildNumber: z.number().nullish(),
+});
+const repoAssociationSchema = z.union([
+    z.object({
+        gitProvider: z.string(),
+        cloneUrl: z.string(),
+    }),
+    z.array(z.unknown()),
+]);
+const environmentsSchema = z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    vars: z.record(z.string(), z.string()).nullish(),
+    secrets: z.record(z.string(), z.string()).nullish(),
+}));
+const liveUpdateChannelsSchema = z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+}));
+const nativeConfigsSchema = z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    configs: z
+        .object({
+        base: z
+            .object({
+            name: z.string().nullish(),
+            bundle_id: z.string().nullish(),
+        })
+            .nullish(),
+        ionic: z.record(z.string(), z.unknown()).nullish(),
+    })
+        .nullish(),
+}));
+const nativeBuildAutomationsSchema = z.array(z.object({
+    name: z.string(),
+    gitBranch: z.string(),
+    platform: z.enum(['android', 'ios']),
+    buildType: z.string().nullish(),
+    environmentId: z.number().nullish(),
+    webhook: z.string().nullish(),
+    automationEnabled: z.boolean(),
+    nativeConfigId: z.number().nullish(),
+    signingCertificateId: z.number().nullish(),
+    destinationId: z.number().nullish(),
+}));
+const webBuildAutomationsSchema = z.array(z.object({
+    name: z.string(),
+    gitBranch: z.string(),
+    environmentId: z.number().nullish(),
+    webhook: z.string().nullish(),
+    automationEnabled: z.boolean(),
+    channelIds: z.array(z.string()).nullish(),
+    webPreviewEnabled: z.boolean().nullish(),
+}));
+const androidSigningCertificateSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    keystoreFile: z.string(),
+    keystorePassword: z.string(),
+    keyAlias: z.string(),
+    keyPassword: z.string(),
+});
+const iosSigningCertificateSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    p12File: z.string(),
+    p12Password: z.string(),
+    provisioningProfiles: z.array(z.string()).nullish(),
+});
+const playStoreDestinationSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    artifactType: z.string().nullish(),
+    packageName: z.string().nullish(),
+    track: z.string().nullish(),
+    releaseStatus: z.string().nullish(),
+});
+const appStoreDestinationSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    appleId: z.string().nullish(),
+    appAppleId: z.string().nullish(),
+    appPassword: z.string().nullish(),
+    teamId: z.string().nullish(),
+});
+export const parseAppflowExport = async (directory) => {
+    const appsDirectory = path.join(directory, 'apps');
+    if (!fs.existsSync(appsDirectory) || !fs.statSync(appsDirectory).isDirectory()) {
+        throw new UserError('The provided file does not look like an Ionic Appflow export. It must contain an `apps` directory.');
+    }
+    const apps = [];
+    const skippedApps = [];
+    const warnings = [];
+    const manifest = parseJsonFileIfExists(path.join(directory, 'manifest.json'), manifestSchema);
+    const majorVersion = manifest?.version?.split('.')[0];
+    if (majorVersion && majorVersion !== SUPPORTED_MANIFEST_MAJOR_VERSION) {
+        warnings.push(`The export has the format version \`${manifest?.version}\` which is not yet supported by this CLI version. The import may be incomplete. Please update the CLI to the latest version.`);
+    }
+    const appFolders = fs
+        .readdirSync(appsDirectory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(appsDirectory, entry.name));
+    for (const appFolder of appFolders) {
+        try {
+            const detail = parseJsonFile(path.join(appFolder, 'app-detail.json'), appDetailSchema);
+            const type = mapAppType(detail.appType);
+            if (!type) {
+                skippedApps.push({
+                    sourceId: detail.id,
+                    sourceName: detail.name,
+                    reason: `App type \`${detail.appType}\` is not yet supported.`,
+                    retryLater: detail.appType === 'react_native' || detail.appType === 'flutter',
+                });
+                continue;
+            }
+            apps.push(parseApp(appFolder, detail, type));
+        }
+        catch (error) {
+            skippedApps.push({
+                sourceId: '',
+                sourceName: path.basename(appFolder),
+                reason: getMessageFromUnknownError(error),
+                retryLater: false,
+            });
+        }
+    }
+    return { apps, skippedApps, warnings };
+};
+const mapAppType = (appType) => {
+    switch (appType) {
+        case 'android':
+        case 'capacitor':
+        case 'cordova':
+        case 'ios':
+            return appType;
+        case 'ionic':
+            // Placeholder only: `ionic` can mean Capacitor or Cordova. The import command
+            // resolves the actual type based on the `sourceAppType` before importing.
+            return 'capacitor';
+        default:
+            return undefined;
+    }
+};
+const parseApp = (appFolder, detail, type) => {
+    const notes = [];
+    const environments = parseJsonFileIfExists(path.join(appFolder, 'environments.json'), environmentsSchema) ?? [];
+    const channels = parseJsonFileIfExists(path.join(appFolder, 'live-update-channels.json'), liveUpdateChannelsSchema) ?? [];
+    const nativeConfigs = parseJsonFileIfExists(path.join(appFolder, 'native-configs.json'), nativeConfigsSchema) ?? [];
+    const certificates = parseCertificates(appFolder, notes);
+    const destinations = parseDestinations(appFolder);
+    return {
+        sourceId: detail.id,
+        sourceName: detail.name,
+        sourceAppType: detail.appType,
+        name: detail.name,
+        type,
+        latestBuildNumber: detail.latestBuildNumber ?? undefined,
+        notes,
+        automations: parseAutomations(appFolder, {
+            certificateNamesById: toNameMap(certificates.map((certificate) => ({ id: certificate.id, name: certificate.certificate.name }))),
+            channelNamesById: new Map(channels.map((channel) => [channel.id, channel.name])),
+            configurationNamesById: toNameMap(nativeConfigs),
+            destinationNamesById: toNameMap(destinations.map((destination) => ({ id: destination.id, name: destination.destination.name }))),
+            environmentNamesById: toNameMap(environments),
+        }, notes),
+        certificates: certificates.map((certificate) => certificate.certificate),
+        channels: channels.map((channel) => channel.name),
+        configurations: parseConfigurations(nativeConfigs, notes),
+        destinations: destinations.map((destination) => 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 })),
+        })),
+        repository: parseRepository(appFolder, notes),
+    };
+};
+const parseRepository = (appFolder, notes) => {
+    const repoAssociation = parseJsonFileIfExists(path.join(appFolder, 'repo-association.json'), repoAssociationSchema);
+    if (!repoAssociation || Array.isArray(repoAssociation)) {
+        return null;
+    }
+    try {
+        return parseGitRemoteUrl(repoAssociation.cloneUrl);
+    }
+    catch {
+        notes.push(`The git repository \`${repoAssociation.cloneUrl}\` (provider \`${repoAssociation.gitProvider}\`) is not supported and was not linked. You can link a repository manually in the Capawesome Cloud Console.`);
+        return null;
+    }
+};
+const parseConfigurations = (nativeConfigs, notes) => {
+    const configurationsWithLiveUpdateSettings = nativeConfigs.filter((config) => config.configs?.ionic);
+    if (configurationsWithLiveUpdateSettings.length > 0) {
+        notes.push(`The native configurations ${configurationsWithLiveUpdateSettings.map((config) => `\`${config.name}\``).join(', ')} contain Live Update plugin settings which are not part of configurations in Capawesome Cloud. Configure the Live Update plugin in your app instead (see ${LIVE_UPDATES_DOCS_URL}).`);
+    }
+    return nativeConfigs.map((config) => ({
+        name: config.name,
+        displayName: config.configs?.base?.name ?? undefined,
+        packageName: config.configs?.base?.bundle_id ?? undefined,
+    }));
+};
+const parseCertificates = (appFolder, notes) => {
+    const certificates = [];
+    for (const folder of getSubfolders(path.join(appFolder, 'signing-certificates', 'android'))) {
+        const metadata = parseJsonFile(path.join(folder, 'android-signing-certificate.json'), androidSigningCertificateSchema);
+        const filePath = resolvePathWithinFolder(folder, metadata.keystoreFile);
+        if (!filePath) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file path \`${metadata.keystoreFile}\` is invalid.`);
+            continue;
+        }
+        if (!fs.existsSync(filePath)) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file \`${metadata.keystoreFile}\` is missing in the export.`);
+            continue;
+        }
+        certificates.push({
+            id: metadata.id,
+            certificate: {
+                name: metadata.name,
+                platform: 'android',
+                filePath,
+                password: metadata.keystorePassword,
+                keyAlias: metadata.keyAlias,
+                keyPassword: metadata.keyPassword,
+                provisioningProfilePaths: [],
+            },
+        });
+    }
+    for (const folder of getSubfolders(path.join(appFolder, 'signing-certificates', 'ios'))) {
+        const metadata = parseJsonFile(path.join(folder, 'ios-signing-certificate.json'), iosSigningCertificateSchema);
+        const filePath = resolvePathWithinFolder(folder, metadata.p12File);
+        if (!filePath) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file path \`${metadata.p12File}\` is invalid.`);
+            continue;
+        }
+        if (!fs.existsSync(filePath)) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file \`${metadata.p12File}\` is missing in the export.`);
+            continue;
+        }
+        const provisioningProfilePaths = [];
+        for (const profileFile of new Set(metadata.provisioningProfiles ?? [])) {
+            const profilePath = resolvePathWithinFolder(folder, profileFile);
+            if (!profilePath) {
+                notes.push(`The provisioning profile \`${profileFile}\` of the signing certificate \`${metadata.name}\` has an invalid file path and was skipped.`);
+                continue;
+            }
+            if (!fs.existsSync(profilePath)) {
+                notes.push(`The provisioning profile \`${profileFile}\` of the signing certificate \`${metadata.name}\` is missing in the export and was skipped.`);
+                continue;
+            }
+            provisioningProfilePaths.push(profilePath);
+        }
+        certificates.push({
+            id: metadata.id,
+            certificate: {
+                name: metadata.name,
+                platform: 'ios',
+                filePath,
+                password: metadata.p12Password,
+                provisioningProfilePaths,
+            },
+        });
+    }
+    return certificates;
+};
+const parseDestinations = (appFolder) => {
+    const destinations = [];
+    for (const folder of getSubfolders(path.join(appFolder, 'store-destinations', 'android'))) {
+        const metadata = parseJsonFile(path.join(folder, 'play-store-destination.json'), playStoreDestinationSchema);
+        const googleServiceAccountKeyPath = path.join(folder, 'json-key.json');
+        destinations.push({
+            id: metadata.id,
+            destination: {
+                name: metadata.name,
+                platform: 'android',
+                androidPackageName: metadata.packageName ?? undefined,
+                androidBuildArtifactType: metadata.artifactType === 'aab' || metadata.artifactType === 'apk' ? metadata.artifactType : undefined,
+                androidReleaseStatus: metadata.releaseStatus === 'completed' || metadata.releaseStatus === 'draft'
+                    ? metadata.releaseStatus
+                    : undefined,
+                googlePlayTrack: metadata.track ?? undefined,
+                googleServiceAccountKeyPath: fs.existsSync(googleServiceAccountKeyPath)
+                    ? googleServiceAccountKeyPath
+                    : undefined,
+            },
+        });
+    }
+    for (const folder of getSubfolders(path.join(appFolder, 'store-destinations', 'ios'))) {
+        const metadata = parseJsonFile(path.join(folder, 'app-store-destination.json'), appStoreDestinationSchema);
+        destinations.push({
+            id: metadata.id,
+            destination: {
+                name: metadata.name,
+                platform: 'ios',
+                appleId: metadata.appleId ?? undefined,
+                appleAppId: metadata.appAppleId ?? undefined,
+                appleTeamId: metadata.teamId ?? undefined,
+                appleAppPassword: metadata.appPassword ?? undefined,
+            },
+        });
+    }
+    return destinations;
+};
+const parseAutomations = (appFolder, references, notes) => {
+    const automations = [];
+    const nativeAutomations = parseJsonFileIfExists(path.join(appFolder, 'native-build-automations.json'), nativeBuildAutomationsSchema) ?? [];
+    const webAutomations = parseJsonFileIfExists(path.join(appFolder, 'web-build-automations.json'), webBuildAutomationsSchema) ?? [];
+    const automationsWithWebhook = [...nativeAutomations, ...webAutomations].filter((automation) => automation.webhook);
+    if (automationsWithWebhook.length > 0) {
+        notes.push(`The webhooks of the automations ${automationsWithWebhook.map((automation) => `\`${automation.name}\``).join(', ')} were not imported because Capawesome Cloud supports webhooks at the app level instead. Please add them manually (see ${WEBHOOKS_DOCS_URL}).`);
+    }
+    for (const automation of nativeAutomations) {
+        let buildType = automation.buildType ?? undefined;
+        if (buildType && !SUPPORTED_BUILD_TYPES.includes(buildType)) {
+            notes.push(`The automation \`${automation.name}\` has the unsupported build type \`${buildType}\` which was skipped.`);
+            buildType = undefined;
+        }
+        automations.push({
+            name: automation.name,
+            platform: automation.platform,
+            triggerPattern: automation.gitBranch,
+            buildType,
+            enabled: automation.automationEnabled,
+            appCertificateName: resolveName(references.certificateNamesById, automation.signingCertificateId, automation.name, 'signing certificate', notes),
+            appConfigurationName: resolveName(references.configurationNamesById, automation.nativeConfigId, automation.name, 'native configuration', notes),
+            appDestinationName: resolveName(references.destinationNamesById, automation.destinationId, automation.name, 'destination', notes),
+            appEnvironmentName: resolveName(references.environmentNamesById, automation.environmentId, automation.name, 'environment', notes),
+        });
+    }
+    for (const automation of webAutomations) {
+        if (automation.webPreviewEnabled) {
+            notes.push(`The automation \`${automation.name}\` has web previews enabled which are not supported by Capawesome Cloud.`);
+        }
+        const channelNames = (automation.channelIds ?? [])
+            .map((channelId) => resolveName(references.channelNamesById, channelId, automation.name, 'channel', notes))
+            .filter((name) => !!name);
+        const appEnvironmentName = resolveName(references.environmentNamesById, automation.environmentId, automation.name, 'environment', notes);
+        if (channelNames.length === 0) {
+            automations.push({
+                name: automation.name,
+                platform: 'web',
+                triggerPattern: automation.gitBranch,
+                enabled: automation.automationEnabled,
+                appEnvironmentName,
+            });
+            continue;
+        }
+        for (const channelName of channelNames) {
+            automations.push({
+                name: channelNames.length > 1 ? `${automation.name} (${channelName})` : automation.name,
+                platform: 'web',
+                triggerPattern: automation.gitBranch,
+                enabled: automation.automationEnabled,
+                appChannelName: channelName,
+                appEnvironmentName,
+            });
+        }
+    }
+    return automations;
+};
+const resolveName = (namesById, id, automationName, label, notes) => {
+    if (id === null || id === undefined) {
+        return undefined;
+    }
+    const name = namesById.get(id);
+    if (!name) {
+        notes.push(`The automation \`${automationName}\` references an unknown ${label} which was skipped.`);
+        return undefined;
+    }
+    return name;
+};
+const toNameMap = (entities) => {
+    return new Map(entities.map((entity) => [entity.id, entity.name]));
+};
+// Guards against path traversal: the file names come from the export's JSON and
+// must never resolve outside the folder they were extracted to.
+const resolvePathWithinFolder = (folder, fileName) => {
+    const filePath = path.resolve(folder, fileName);
+    return filePath.startsWith(folder + path.sep) ? filePath : undefined;
+};
+const getSubfolders = (directory) => {
+    if (!fs.existsSync(directory)) {
+        return [];
+    }
+    return fs
+        .readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(directory, entry.name));
+};
+const parseJsonFile = (filePath, schema) => {
+    let json;
+    try {
+        json = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        throw new UserError(`The export file \`${path.basename(filePath)}\` is missing or contains invalid JSON.`);
+    }
+    const result = schema.safeParse(json);
+    if (!result.success) {
+        throw new UserError(`The export file \`${path.basename(filePath)}\` has an unexpected format.`);
+    }
+    return result.data;
+};
+const parseJsonFileIfExists = (filePath, schema) => {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    return parseJsonFile(filePath, schema);
+};