@capawesome/cli 4.18.3 → 4.19.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [4.19.0](https://github.com/capawesome-team/cli/compare/v4.18.4...v4.19.0) (2026-09-22)
+
+
+### Features
+
+* add `apps:import` command ([#217](https://github.com/capawesome-team/cli/issues/217)) ([db90d04](https://github.com/capawesome-team/cli/commit/db90d04d3001e517fa105f37b79be82c146260ba))
+* **apps:** support multiple and negated trigger patterns ([#214](https://github.com/capawesome-team/cli/issues/214)) ([0f56afa](https://github.com/capawesome-team/cli/commit/0f56afadfb24c3411f63d380d66188055a23388c))
+
+## [4.18.4](https://github.com/capawesome-team/cli/compare/v4.18.3...v4.18.4) (2026-08-20)
+
+
+### Bug Fixes
+
+* report unreadable files with an actionable error message ([#208](https://github.com/capawesome-team/cli/issues/208)) ([cc18dee](https://github.com/capawesome-team/cli/commit/cc18dee898658c99affd660c99e64ef8e45cdf9a))
+
 ## [4.18.3](https://github.com/capawesome-team/cli/compare/v4.18.2...v4.18.3) (2026-08-18)
 
 

package/README.md

@@ -22,7 +22,7 @@ The Capawesome Cloud CLI can be invoked with the `@capawesome/cli` command.
 npx @capawesome/cli <command> [options]
 ```
 
-You can find a list of available commands in the [Command Reference](https://capawesome.io/cloud/cli/).
+You can find a list of available commands in the [Command Reference](https://capawesome.io/docs/cloud/cli/commands/).
 
 ## Help
 

package/dist/commands/apps/automations/create.js

@@ -34,9 +34,9 @@ export default defineCommand({
             .optional()
             .describe('The build stack to use for the build process.'),
         triggerPattern: z
-            .string()
+            .array(z.string())
             .optional()
-            .describe('Only trigger for branches or tags matching this pattern. Defaults to all.'),
+            .describe('Only trigger for branches or tags matching this pattern. Prefix with `!` to exclude. Can be specified multiple times. Defaults to all.'),
         triggerType: z
             .enum(['branch', 'tag'], {
             message: 'Trigger type must be either `branch` or `tag`.',
@@ -44,8 +44,8 @@ export default defineCommand({
             .optional()
             .describe('What triggers the automation. Supported values are `branch` and `tag`.'),
         type: z
-            .enum(['app-store', 'ad-hoc', 'debug', 'development', 'release', 'simulator'], {
-            message: 'Build type must be one of `app-store`, `ad-hoc`, `debug`, `development`, `release`, or `simulator`.',
+            .enum(['app-store', 'ad-hoc', 'debug', 'development', 'enterprise', 'release', 'simulator'], {
+            message: 'Build type must be one of `app-store`, `ad-hoc`, `debug`, `development`, `enterprise`, `release`, or `simulator`.',
         })
             .optional()
             .describe('The type of build to create.'),
@@ -127,7 +127,7 @@ export default defineCommand({
             commitMessagePattern: options.commitMessagePattern,
             name,
             platform,
-            triggerPattern: options.triggerPattern,
+            triggerPatterns: options.triggerPattern,
             triggerType,
         });
         if (json) {

package/dist/commands/apps/automations/create.test.js

@@ -45,7 +45,7 @@ describe('apps-automations-create', () => {
             name: 'nightly',
             platform: 'android',
             stack: 'macos-tahoe',
-            triggerPattern: 'main',
+            triggerPattern: ['release/*', '!release/*-alpha'],
             triggerType: 'branch',
             type: 'release',
         };
@@ -58,7 +58,7 @@ describe('apps-automations-create', () => {
             buildType: 'release',
             name: 'nightly',
             platform: 'android',
-            triggerPattern: 'main',
+            triggerPatterns: ['release/*', '!release/*-alpha'],
             triggerType: 'branch',
         })
             .matchHeader('Authorization', 'Bearer test-token')

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

@@ -6,6 +6,7 @@ import consola from 'consola';
 import { z } from 'zod';
 import { defineCommand, defineOptions } from 'zodline';
 const clearableValue = (value) => (value === '' ? null : value);
+const clearableValues = (values) => values?.filter((value) => value !== '');
 export default defineCommand({
     description: 'Update an existing app automation.',
     options: defineOptions(z.object({
@@ -50,9 +51,9 @@ export default defineCommand({
             .optional()
             .describe('The build stack to use for the build process.'),
         triggerPattern: z
-            .string()
+            .array(z.string())
             .optional()
-            .describe('Only trigger for branches or tags matching this pattern. Pass an empty string to clear it.'),
+            .describe('Only trigger for branches or tags matching this pattern. Prefix with `!` to exclude. Can be specified multiple times. Pass an empty string to clear them.'),
         triggerType: z
             .enum(['branch', 'tag'], {
             message: 'Trigger type must be either `branch` or `tag`.',
@@ -60,8 +61,8 @@ export default defineCommand({
             .optional()
             .describe('What triggers the automation. Supported values are `branch` and `tag`.'),
         type: z
-            .enum(['app-store', 'ad-hoc', 'debug', 'development', 'release', 'simulator'], {
-            message: 'Build type must be one of `app-store`, `ad-hoc`, `debug`, `development`, `release`, or `simulator`.',
+            .enum(['app-store', 'ad-hoc', 'debug', 'development', 'enterprise', 'release', 'simulator'], {
+            message: 'Build type must be one of `app-store`, `ad-hoc`, `debug`, `development`, `enterprise`, `release`, or `simulator`.',
         })
             .optional()
             .describe('The type of build to create.'),
@@ -105,7 +106,7 @@ export default defineCommand({
             commitMessagePattern: clearableValue(options.commitMessagePattern),
             name: options.name,
             platform: options.platform,
-            triggerPattern: clearableValue(options.triggerPattern),
+            triggerPatterns: clearableValues(options.triggerPattern),
             triggerType: options.triggerType,
         });
         if (json) {

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

@@ -42,13 +42,13 @@ describe('apps-automations-update', () => {
             automationId,
             configuration: 'Production',
             name: 'renamed',
-            triggerPattern: 'release/*',
+            triggerPattern: ['v*', '!v*-*'],
         };
         const scope = nock(DEFAULT_API_BASE_URL)
             .patch(`/v1/apps/${appId}/automations/${automationId}`, {
             appConfigurationName: 'Production',
             name: 'renamed',
-            triggerPattern: 'release/*',
+            triggerPatterns: ['v*', '!v*-*'],
         })
             .matchHeader('Authorization', 'Bearer test-token')
             .reply(204);
@@ -59,11 +59,11 @@ describe('apps-automations-update', () => {
     it('should clear a reference when an empty string is passed', async () => {
         const appId = 'app-123';
         const automationId = 'automation-456';
-        const options = { appId, automationId, certificate: '', triggerPattern: '' };
+        const options = { appId, automationId, certificate: '', triggerPattern: [''] };
         const scope = nock(DEFAULT_API_BASE_URL)
             .patch(`/v1/apps/${appId}/automations/${automationId}`, {
             appCertificateName: null,
-            triggerPattern: null,
+            triggerPatterns: [],
         })
             .matchHeader('Authorization', 'Bearer test-token')
             .reply(204);

package/dist/commands/apps/import.js

@@ -0,0 +1,479 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../config/consts.js';
+import appAutomationsService from '../../services/app-automations.js';
+import appCertificatesService from '../../services/app-certificates.js';
+import appChannelsService from '../../services/app-channels.js';
+import appConfigurationsService from '../../services/app-configurations.js';
+import appDestinationsService from '../../services/app-destinations.js';
+import appEnvironmentsService from '../../services/app-environments.js';
+import appGoogleServiceAccountKeysService from '../../services/app-google-service-account-keys.js';
+import appProvisioningProfilesService from '../../services/app-provisioning-profiles.js';
+import appsService from '../../services/apps.js';
+import { generateUniqueAppName } from '../../utils/app-import.js';
+import { parseAppflowExport } from '../../utils/appflow-export.js';
+import { withAuth } from '../../utils/auth.js';
+import { isInteractive } from '../../utils/environment.js';
+import { getMessageFromUnknownError, UserError } from '../../utils/error.js';
+import { isReadable } from '../../utils/file.js';
+import { prompt, promptOrganizationSelection } from '../../utils/prompt.js';
+import zip from '../../utils/zip.js';
+import { defineCommand, defineOptions } from 'zodline';
+import consola from 'consola';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Import apps from an Ionic Appflow export.',
+    options: defineOptions(z.object({
+        dryRun: z.boolean().optional().describe('Preview the import without creating any resources.'),
+        file: z.string().optional().describe('Path to the export file (.zip).'),
+        include: z
+            .array(z.string())
+            .optional()
+            .describe('Filter which apps to import by name or ID. Can be specified multiple times or comma-separated. Defaults to all apps.'),
+        ionicAppType: z
+            .enum(['capacitor', 'cordova'], {
+            message: 'Ionic app type must be either `capacitor` or `cordova`.',
+        })
+            .optional()
+            .describe('The actual app type of apps exported with the ambiguous app type `ionic`. Prompted for each app if not provided.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        organizationId: z.string().optional().describe('ID of the organization to import the apps into.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { dryRun, file, include, ionicAppType, json, organizationId } = options;
+        if (!file) {
+            if (!isInteractive()) {
+                consola.error('You must provide the export file path when running in non-interactive environment.');
+                process.exit(1);
+            }
+            file = await prompt('Enter the path to the export file (.zip):', { type: 'text' });
+            if (!file) {
+                consola.error('You must provide an export file path.');
+                process.exit(1);
+            }
+        }
+        if (!zip.isZipped(file)) {
+            consola.error('The export file must be a `.zip` file.');
+            process.exit(1);
+        }
+        const fileReadable = await isReadable(file);
+        if (!fileReadable) {
+            consola.error(`The export file does not exist or is not accessible: ${file}`);
+            process.exit(1);
+        }
+        if (!organizationId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an organization ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            organizationId = await promptOrganizationSelection({
+                message: 'Which organization do you want to import the apps into?',
+            });
+        }
+        const tempDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'capawesome-appflow-import-'));
+        try {
+            await zip.unzipToFolder(fs.readFileSync(file), tempDirectory);
+            const { apps, skippedApps, warnings } = await parseAppflowExport(tempDirectory);
+            for (const warning of warnings) {
+                consola.warn(warning);
+            }
+            const { selectedApps, selectedSkippedApps } = await selectApps(apps, skippedApps, include);
+            if (selectedApps.length === 0 && selectedSkippedApps.length === 0) {
+                throw new UserError('No apps found in the export that match the provided filters.');
+            }
+            const { resolvedApps, skippedApps: unresolvedApps } = await resolveIonicAppTypes(selectedApps, ionicAppType);
+            selectedSkippedApps.push(...unresolvedApps);
+            await assignUniqueAppNames(resolvedApps, organizationId);
+            const outcomes = [];
+            for (const app of resolvedApps) {
+                const outcome = {
+                    app,
+                    errors: [],
+                    created: {
+                        automations: 0,
+                        certificates: 0,
+                        channels: 0,
+                        configurations: 0,
+                        destinations: 0,
+                        environments: 0,
+                    },
+                };
+                outcomes.push(outcome);
+                if (dryRun) {
+                    continue;
+                }
+                await importApp(organizationId, outcome);
+            }
+            const errorCount = outcomes.reduce((count, outcome) => count + outcome.errors.length, 0);
+            if (json) {
+                printJsonSummary(outcomes, selectedSkippedApps, warnings, dryRun === true);
+            }
+            else {
+                printSummary(outcomes, selectedSkippedApps, dryRun === true, file);
+            }
+            if (errorCount > 0) {
+                // Set the exit code instead of calling `process.exit` so the `finally` block
+                // still deletes the extracted export, which contains secrets.
+                process.exitCode = 1;
+            }
+        }
+        finally {
+            fs.rmSync(tempDirectory, { recursive: true, force: true });
+        }
+    }),
+});
+const selectApps = async (apps, skippedApps, include) => {
+    const filters = include
+        ?.flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    if (filters && filters.length > 0) {
+        const matchesFilter = (sourceId, sourceName) => filters.some((filter) => filter === sourceId || filter === sourceName);
+        for (const filter of filters) {
+            const matched = apps.some((app) => app.sourceId === filter || app.sourceName === filter) ||
+                skippedApps.some((app) => app.sourceId === filter || app.sourceName === filter);
+            if (!matched) {
+                consola.warn(`No app in the export matches the filter \`${filter}\`.`);
+            }
+        }
+        return {
+            selectedApps: apps.filter((app) => matchesFilter(app.sourceId, app.sourceName)),
+            selectedSkippedApps: skippedApps.filter((app) => matchesFilter(app.sourceId, app.sourceName)),
+        };
+    }
+    if (isInteractive() && apps.length > 1) {
+        // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+        const selectedIds = await prompt('Which apps do you want to import?', {
+            type: 'multiselect',
+            options: apps.map((app) => ({ label: `${app.sourceName} (${app.sourceId})`, value: app.sourceId })),
+            initial: apps.map((app) => app.sourceId),
+        });
+        return {
+            selectedApps: apps.filter((app) => selectedIds.includes(app.sourceId)),
+            selectedSkippedApps: skippedApps,
+        };
+    }
+    return { selectedApps: apps, selectedSkippedApps: skippedApps };
+};
+const resolveIonicAppTypes = async (apps, ionicAppType) => {
+    const resolvedApps = [];
+    const skippedApps = [];
+    for (const app of apps) {
+        if (app.sourceAppType !== 'ionic') {
+            resolvedApps.push(app);
+            continue;
+        }
+        let type = ionicAppType;
+        if (!type && isInteractive()) {
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            type = await prompt(`The app \`${app.sourceName}\` was exported with the app type \`ionic\` which can mean Capacitor or Cordova. Which framework does the app use?`, {
+                type: 'select',
+                options: [
+                    { label: 'Capacitor', value: 'capacitor' },
+                    { label: 'Cordova', value: 'cordova' },
+                ],
+            });
+        }
+        if (!type) {
+            skippedApps.push({
+                sourceId: app.sourceId,
+                sourceName: app.sourceName,
+                reason: 'The app was exported with the ambiguous app type `ionic` which can mean Capacitor or Cordova. Provide the `--ionic-app-type` option or run the import interactively.',
+                retryLater: false,
+            });
+            continue;
+        }
+        app.type = type;
+        app.notes.push(`The app type \`ionic\` was resolved to \`${type}\`.`);
+        resolvedApps.push(app);
+    }
+    return { resolvedApps, skippedApps };
+};
+const assignUniqueAppNames = async (apps, organizationId) => {
+    const takenNames = new Set();
+    const limit = 50;
+    let offset = 0;
+    while (true) {
+        const page = await appsService.findAll({ organizationId, limit, offset });
+        for (const app of page) {
+            takenNames.add(app.name);
+        }
+        if (page.length < limit) {
+            break;
+        }
+        offset += limit;
+    }
+    for (const app of apps) {
+        app.name = generateUniqueAppName(app.sourceName, takenNames);
+        takenNames.add(app.name);
+        if (app.name !== app.sourceName) {
+            app.notes.push(`An app with the name \`${app.sourceName}\` already exists in the organization. The app is imported as \`${app.name}\`.`);
+        }
+    }
+};
+const importApp = async (organizationId, outcome) => {
+    const { app } = outcome;
+    consola.start(`Importing app \`${app.sourceName}\`...`);
+    let appId;
+    try {
+        const createdApp = await appsService.create({ name: app.name, organizationId, type: app.type });
+        appId = createdApp.id;
+        outcome.id = appId;
+        consola.success(`Created app \`${app.name}\`.`);
+    }
+    catch (error) {
+        outcome.errors.push(`Failed to create app: ${getMessageFromUnknownError(error)}`);
+        consola.error(`Failed to create app \`${app.name}\`.`);
+        return;
+    }
+    if (app.latestBuildNumber && app.latestBuildNumber > 0) {
+        const nextAppBuildNumber = app.latestBuildNumber + 1;
+        try {
+            await appsService.update({ appId, nextAppBuildNumber });
+            app.notes.push(`The next build number was set to \`${nextAppBuildNumber}\` to continue after the latest build number \`${app.latestBuildNumber}\`.`);
+            consola.success(`Set the next build number to ${nextAppBuildNumber}.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to set the next build number: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    for (const certificate of app.certificates) {
+        try {
+            const provisioningProfileIds = [];
+            for (const profilePath of certificate.provisioningProfilePaths) {
+                const profile = await appProvisioningProfilesService.create({
+                    appId,
+                    buffer: fs.readFileSync(profilePath),
+                    fileName: path.basename(profilePath),
+                });
+                provisioningProfileIds.push(profile.id);
+            }
+            const createdCertificate = await appCertificatesService.create({
+                appId,
+                buffer: fs.readFileSync(certificate.filePath),
+                fileName: path.basename(certificate.filePath),
+                name: certificate.name,
+                platform: certificate.platform,
+                password: certificate.password,
+                keyAlias: certificate.keyAlias,
+                keyPassword: certificate.keyPassword,
+            });
+            if (provisioningProfileIds.length > 0) {
+                await appProvisioningProfilesService.updateMany({
+                    appId,
+                    ids: provisioningProfileIds,
+                    appCertificateId: createdCertificate.id,
+                });
+            }
+            outcome.created.certificates++;
+            consola.success(`Created certificate \`${certificate.name}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create certificate \`${certificate.name}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    for (const environment of app.environments) {
+        try {
+            const createdEnvironment = await appEnvironmentsService.create({ appId, name: environment.name });
+            if (environment.variables.length > 0) {
+                await appEnvironmentsService.setVariables({
+                    appId,
+                    environmentId: createdEnvironment.id,
+                    variables: environment.variables,
+                });
+            }
+            if (environment.secrets.length > 0) {
+                await appEnvironmentsService.setSecrets({
+                    appId,
+                    environmentId: createdEnvironment.id,
+                    secrets: environment.secrets,
+                });
+            }
+            outcome.created.environments++;
+            consola.success(`Created environment \`${environment.name}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create environment \`${environment.name}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    let existingChannelNames = new Set();
+    try {
+        const existingChannels = await appChannelsService.findAll({ appId });
+        existingChannelNames = new Set(existingChannels.map((channel) => channel.name));
+    }
+    catch {
+        // If the lookup fails, channel creation errors are reported individually below.
+    }
+    for (const channel of app.channels) {
+        if (existingChannelNames.has(channel)) {
+            outcome.created.channels++;
+            continue;
+        }
+        try {
+            await appChannelsService.create({ appId, name: channel });
+            outcome.created.channels++;
+            consola.success(`Created channel \`${channel}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create channel \`${channel}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    for (const configuration of app.configurations) {
+        try {
+            await appConfigurationsService.create({
+                appId,
+                name: configuration.name,
+                displayName: configuration.displayName,
+                packageName: configuration.packageName,
+            });
+            outcome.created.configurations++;
+            consola.success(`Created configuration \`${configuration.name}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create configuration \`${configuration.name}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    for (const destination of app.destinations) {
+        try {
+            let appGoogleServiceAccountKeyId;
+            if (destination.googleServiceAccountKeyPath) {
+                const key = await appGoogleServiceAccountKeysService.create({
+                    appId,
+                    buffer: fs.readFileSync(destination.googleServiceAccountKeyPath),
+                    fileName: path.basename(destination.googleServiceAccountKeyPath),
+                });
+                appGoogleServiceAccountKeyId = key.id;
+            }
+            await appDestinationsService.create({
+                appId,
+                name: destination.name,
+                platform: destination.platform,
+                androidPackageName: destination.androidPackageName,
+                androidBuildArtifactType: destination.androidBuildArtifactType,
+                androidReleaseStatus: destination.androidReleaseStatus,
+                googlePlayTrack: destination.googlePlayTrack,
+                appGoogleServiceAccountKeyId,
+                appleId: destination.appleId,
+                appleAppId: destination.appleAppId,
+                appleTeamId: destination.appleTeamId,
+                appleAppPassword: destination.appleAppPassword,
+            });
+            outcome.created.destinations++;
+            consola.success(`Created destination \`${destination.name}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create destination \`${destination.name}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    for (const automation of app.automations) {
+        try {
+            await appAutomationsService.create({
+                appId,
+                name: automation.name,
+                platform: automation.platform,
+                triggerType: 'branch',
+                triggerPatterns: [automation.triggerPattern],
+                buildType: automation.buildType,
+                enabled: automation.enabled,
+                appCertificateName: automation.appCertificateName,
+                appChannelName: automation.appChannelName,
+                appConfigurationName: automation.appConfigurationName,
+                appDestinationName: automation.appDestinationName,
+                appEnvironmentName: automation.appEnvironmentName,
+            });
+            outcome.created.automations++;
+            consola.success(`Created automation \`${automation.name}\`.`);
+        }
+        catch (error) {
+            outcome.errors.push(`Failed to create automation \`${automation.name}\`: ${getMessageFromUnknownError(error)}`);
+        }
+    }
+    if (app.repository) {
+        try {
+            await appsService.linkRepository({
+                appId,
+                ownerSlug: app.repository.ownerSlug,
+                provider: app.repository.provider,
+                repositorySlug: app.repository.repositorySlug,
+                projectSlug: app.repository.projectSlug,
+            });
+            consola.success(`Linked repository \`${app.repository.ownerSlug}/${app.repository.repositorySlug}\`.`);
+        }
+        catch (error) {
+            app.notes.push(`The repository \`${app.repository.ownerSlug}/${app.repository.repositorySlug}\` could not be linked: ${getMessageFromUnknownError(error)} Make sure the git provider is connected in the Capawesome Cloud Console and link the repository manually.`);
+        }
+    }
+};
+const printSummary = (outcomes, skippedApps, dryRun, file) => {
+    consola.log('');
+    if (dryRun) {
+        consola.info('Dry run. No resources were created.');
+    }
+    console.table(outcomes.map((outcome) => ({
+        App: outcome.app.sourceName,
+        'Imported as': dryRun || outcome.id ? outcome.app.name : '—',
+        Certificates: formatCount(outcome.created.certificates, outcome.app.certificates.length, dryRun),
+        Environments: formatCount(outcome.created.environments, outcome.app.environments.length, dryRun),
+        Channels: formatCount(outcome.created.channels, outcome.app.channels.length, dryRun),
+        Configurations: formatCount(outcome.created.configurations, outcome.app.configurations.length, dryRun),
+        Destinations: formatCount(outcome.created.destinations, outcome.app.destinations.length, dryRun),
+        Automations: formatCount(outcome.created.automations, outcome.app.automations.length, dryRun),
+        Errors: outcome.errors.length,
+    })));
+    for (const outcome of outcomes) {
+        if (outcome.app.notes.length === 0 && outcome.errors.length === 0) {
+            continue;
+        }
+        consola.log(`\n${outcome.app.sourceName}:`);
+        for (const note of outcome.app.notes) {
+            consola.warn(note);
+        }
+        for (const error of outcome.errors) {
+            consola.error(error);
+        }
+    }
+    for (const outcome of outcomes) {
+        if (outcome.id) {
+            consola.info(`App URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${outcome.id}`);
+        }
+    }
+    const retryLaterApps = skippedApps.filter((app) => app.retryLater);
+    const otherSkippedApps = skippedApps.filter((app) => !app.retryLater);
+    for (const app of otherSkippedApps) {
+        consola.warn(`The app \`${app.sourceName}\` was skipped: ${app.reason}`);
+    }
+    if (retryLaterApps.length > 0) {
+        const includeValues = retryLaterApps
+            .map((app) => (app.sourceName.includes(',') ? app.sourceId : app.sourceName))
+            .join(',');
+        consola.info(`The apps ${retryLaterApps.map((app) => `\`${app.sourceName}\``).join(', ')} were skipped because their app type is not yet supported. Support is coming soon. You can import the remaining apps later by running:\n\nnpx @capawesome/cli apps:import --file "${file}" --include "${includeValues}"`);
+    }
+    if (!dryRun) {
+        consola.success('Import completed.');
+    }
+};
+const formatCount = (created, total, dryRun) => {
+    return dryRun ? `${total}` : `${created}/${total}`;
+};
+const printJsonSummary = (outcomes, skippedApps, warnings, dryRun) => {
+    console.log(JSON.stringify({
+        dryRun,
+        warnings,
+        apps: outcomes.map((outcome) => ({
+            id: outcome.id ?? null,
+            name: outcome.app.name,
+            sourceId: outcome.app.sourceId,
+            sourceName: outcome.app.sourceName,
+            webUrl: outcome.id ? `${DEFAULT_CONSOLE_BASE_URL}/apps/${outcome.id}` : null,
+            created: outcome.created,
+            notes: outcome.app.notes,
+            errors: outcome.errors,
+        })),
+        skippedApps: skippedApps.map((app) => ({
+            sourceId: app.sourceId,
+            sourceName: app.sourceName,
+            reason: app.reason,
+        })),
+    }, null, 2));
+};