@capawesome/cli 4.3.0 → 4.5.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 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.5.0](https://github.com/capawesome-team/cli/compare/v4.4.0...v4.5.0) (2026-03-15)
+
+
+### Features
+
+* add certificate and destination CRUD commands ([#126](https://github.com/capawesome-team/cli/issues/126)) ([2d5e3cf](https://github.com/capawesome-team/cli/commit/2d5e3cfc80518fc1237dbc926a57c4a2eddf2b31))
+* **apps:builds:create:** add `--channel` and `--destination` options ([#127](https://github.com/capawesome-team/cli/issues/127)) ([baab841](https://github.com/capawesome-team/cli/commit/baab841d330c7bf230dbbf8e0819f3aaf248867b))
+* **update:** add dev version detection in update check ([#128](https://github.com/capawesome-team/cli/issues/128)) ([5004095](https://github.com/capawesome-team/cli/commit/50040958cd2a873ff296981b0950b3a799505a93))
+
+
+### Bug Fixes
+
+* **apps:builds:create:** allow certificate selection for web platform ([a038251](https://github.com/capawesome-team/cli/commit/a03825128b8380f86dcf85e8d3507b3a41d9f775))
+* create parent directories before writing signing key files ([#125](https://github.com/capawesome-team/cli/issues/125)) ([e152606](https://github.com/capawesome-team/cli/commit/e152606d1d9c1758e922379e5bbda0764261c711))
+
+## [4.4.0](https://github.com/capawesome-team/cli/compare/v4.3.0...v4.4.0) (2026-03-13)
+
+
+### Features
+
+* add `apps:devices:forcechannel` and `apps:devices:unforcechannel` commands ([#124](https://github.com/capawesome-team/cli/issues/124)) ([c47c15f](https://github.com/capawesome-team/cli/commit/c47c15fc8328824973dd9062bfac2bca2e847752))
+* add deprecation warning for `--expires-in-days` option ([#123](https://github.com/capawesome-team/cli/issues/123)) ([db628a2](https://github.com/capawesome-team/cli/commit/db628a21b50b826d59a1b29eb3913c1f6ce225bf))
+* add warning when using manifest artifact type ([42a6b2b](https://github.com/capawesome-team/cli/commit/42a6b2bfae0cc958127d4ff60562000eb9713943))
+
 ## [4.3.0](https://github.com/capawesome-team/cli/compare/v4.2.1...v4.3.0) (2026-03-07)
 
 

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

@@ -32,6 +32,8 @@ export default defineCommand({
             .optional()
             .describe('App ID to create the build for.'),
         certificate: z.string().optional().describe('The name of the certificate to use for the build.'),
+        channel: z.string().optional().describe('The name of the channel to deploy to (Web only).'),
+        destination: z.string().optional().describe('The name of the destination to deploy to (Android/iOS only).'),
         detached: z
             .boolean()
             .optional()
@@ -72,6 +74,16 @@ export default defineCommand({
             consola.error('The --detached flag cannot be used with --apk, --aab, --ipa, or --zip flags.');
             process.exit(1);
         }
+        // Validate that detached flag cannot be used with channel or destination
+        if (options.detached && (options.channel || options.destination)) {
+            consola.error('The --detached flag cannot be used with --channel or --destination flags.');
+            process.exit(1);
+        }
+        // Validate that channel and destination cannot be used together
+        if (options.channel && options.destination) {
+            consola.error('The --channel and --destination flags cannot be used together.');
+            process.exit(1);
+        }
         // Prompt for app ID if not provided
         if (!appId) {
             if (!isInteractive()) {
@@ -133,6 +145,16 @@ export default defineCommand({
             consola.error(`Invalid build type for Android. Supported values are: ${ANDROID_BUILD_TYPES.map((t) => `\`${t}\``).join(', ')}.`);
             process.exit(1);
         }
+        // Validate that channel is only used with web platform
+        if (options.channel && platform !== 'web') {
+            consola.error('The --channel flag can only be used with the web platform.');
+            process.exit(1);
+        }
+        // Validate that destination is only used with non-web platforms
+        if (options.destination && platform === 'web') {
+            consola.error('The --destination flag cannot be used with the web platform.');
+            process.exit(1);
+        }
         // Prompt for environment if not provided
         if (!environment && !options.yes && isInteractive()) {
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
@@ -154,8 +176,8 @@ export default defineCommand({
                 }
             }
         }
-        // Prompt for certificate if not provided (skip for web platform)
-        if (!certificate && !options.yes && isInteractive() && platform !== 'web') {
+        // Prompt for certificate if not provided
+        if (!certificate && !options.yes && isInteractive()) {
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
             const selectCertificate = await prompt('Do you want to select a certificate?', {
                 type: 'confirm',
@@ -288,8 +310,7 @@ export default defineCommand({
                                     numberAsString: response.numberAsString,
                                 }, null, 2));
                             }
-                            // Exit successfully
-                            process.exit(0);
+                            break;
                         }
                         else if (jobStatus === 'failed') {
                             consola.error('Build failed.');
@@ -331,6 +352,10 @@ export default defineCommand({
                 consola.success(`Build completed successfully.`);
             }
         }
+        // Create deployment if channel or destination is set
+        if (options.channel || options.destination) {
+            await (await import('../../../commands/apps/deployments/create.js').then((mod) => mod.default)).action({ appId, buildId: response.id, channel: options.channel, destination: options.destination }, undefined);
+        }
     }),
 });
 /**

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

@@ -0,0 +1,186 @@
+import appCertificatesService from '../../../services/app-certificates.js';
+import appProvisioningProfilesService from '../../../services/app-provisioning-profiles.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new app certificate.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        file: z.string().optional().describe('Path to the certificate file.'),
+        keyAlias: z.string().optional().describe('Key alias for the certificate.'),
+        keyPassword: z.string().optional().describe('Key password for the certificate.'),
+        name: z.string().optional().describe('Name of the certificate.'),
+        password: z.string().optional().describe('Password for the certificate.'),
+        platform: z
+            .enum(['android', 'ios', 'web'])
+            .optional()
+            .describe('Platform of the certificate (android, ios, web).'),
+        provisioningProfile: z
+            .array(z.string())
+            .optional()
+            .describe('Paths to provisioning profile files to upload and link.'),
+        type: z
+            .enum(['development', 'production'])
+            .optional()
+            .describe('Type of the certificate (development, production).'),
+        yes: z.boolean().optional().describe('Skip confirmation prompts.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options, args) => {
+        let { appId, file, keyAlias, keyPassword, name, password, platform, provisioningProfile, type } = options;
+        // 1. Select organization and app
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        // 2. Enter certificate name
+        if (!name) {
+            if (!isInteractive()) {
+                consola.error('You must provide the certificate name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            name = await prompt('Enter the name of the certificate:', { type: 'text' });
+            if (!name) {
+                consola.error('You must provide a certificate name.');
+                process.exit(1);
+            }
+        }
+        // 3. Select platform
+        if (!platform) {
+            if (!isInteractive()) {
+                consola.error('You must provide the platform when running in non-interactive environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            platform = await prompt('Select the platform:', {
+                type: 'select',
+                options: [
+                    { label: 'Android', value: 'android' },
+                    { label: 'iOS', value: 'ios' },
+                    { label: 'Web', value: 'web' },
+                ],
+            });
+            if (!platform) {
+                consola.error('You must select a platform.');
+                process.exit(1);
+            }
+        }
+        // 4. Select certificate type
+        if (!type) {
+            if (!isInteractive()) {
+                consola.error('You must provide the certificate type when running in non-interactive environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            type = await prompt('Select the certificate type:', {
+                type: 'select',
+                options: [
+                    { label: 'Development', value: 'development' },
+                    { label: 'Production', value: 'production' },
+                ],
+            });
+            if (!type) {
+                consola.error('You must select a certificate type.');
+                process.exit(1);
+            }
+        }
+        // 5. Enter certificate file path
+        if (!file) {
+            if (!isInteractive()) {
+                consola.error('You must provide a certificate file path when running in non-interactive environment.');
+                process.exit(1);
+            }
+            file = await prompt('Enter the path to the certificate file:', { type: 'text' });
+            if (!file) {
+                consola.error('You must provide a certificate file path.');
+                process.exit(1);
+            }
+        }
+        // 6. Enter certificate password (required for android/ios)
+        if (!password && (platform === 'android' || platform === 'ios')) {
+            if (!isInteractive()) {
+                consola.error('You must provide the certificate password when running in non-interactive environment.');
+                process.exit(1);
+            }
+            password = await prompt('Enter the certificate password:', { type: 'text' });
+            if (!password) {
+                consola.error('You must provide a certificate password.');
+                process.exit(1);
+            }
+        }
+        // 7. If Android, ask for key alias (required)
+        if (!keyAlias && platform === 'android') {
+            if (!isInteractive()) {
+                consola.error('You must provide the key alias when running in non-interactive environment.');
+                process.exit(1);
+            }
+            keyAlias = await prompt('Enter the key alias:', { type: 'text' });
+            if (!keyAlias) {
+                consola.error('You must provide a key alias.');
+                process.exit(1);
+            }
+        }
+        // 8. If Android, ask for key password (optional, skip with --yes)
+        if (!keyPassword && platform === 'android' && !options.yes && isInteractive()) {
+            keyPassword = await prompt('Enter the key password (leave empty if none):', { type: 'text' });
+            if (!keyPassword) {
+                keyPassword = undefined;
+            }
+        }
+        // 9. If iOS, ask for provisioning profile file path (optional, skip with --yes)
+        if (!provisioningProfile && platform === 'ios' && !options.yes && isInteractive()) {
+            const profilePath = await prompt('Enter the path to the provisioning profile file (leave empty to skip):', {
+                type: 'text',
+            });
+            if (profilePath) {
+                provisioningProfile = [profilePath];
+            }
+        }
+        const buffer = fs.readFileSync(file);
+        const fileName = path.basename(file);
+        // Upload provisioning profiles first
+        const provisioningProfileIds = [];
+        if (provisioningProfile && provisioningProfile.length > 0) {
+            for (const profilePath of provisioningProfile) {
+                const profileBuffer = fs.readFileSync(profilePath);
+                const profileFileName = path.basename(profilePath);
+                const profile = await appProvisioningProfilesService.create({
+                    appId,
+                    buffer: profileBuffer,
+                    fileName: profileFileName,
+                });
+                provisioningProfileIds.push(profile.id);
+            }
+        }
+        const certificate = await appCertificatesService.create({
+            appId,
+            buffer,
+            fileName,
+            name,
+            platform: platform,
+            type: type,
+            password,
+            keyAlias,
+            keyPassword,
+        });
+        // Link provisioning profiles to the certificate
+        if (provisioningProfileIds.length > 0) {
+            await appProvisioningProfilesService.updateMany({
+                appId,
+                ids: provisioningProfileIds,
+                appCertificateId: certificate.id,
+            });
+        }
+        consola.info(`Certificate ID: ${certificate.id}`);
+        consola.success('Certificate created successfully.');
+    }),
+});

package/dist/commands/apps/certificates/delete.js

@@ -0,0 +1,79 @@
+import appCertificatesService from '../../../services/app-certificates.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Delete an app certificate.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        certificateId: z.string().optional().describe('ID of the certificate.'),
+        name: z.string().optional().describe('Name of the certificate.'),
+        platform: z
+            .enum(['android', 'ios', 'web'])
+            .optional()
+            .describe('Platform of the certificate (android, ios, web).'),
+        yes: z.boolean().optional().describe('Skip confirmation prompt.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options, args) => {
+        let { appId, certificateId, name, platform } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!certificateId) {
+            if (name && platform) {
+                const certificates = await appCertificatesService.findAll({ appId, name, platform });
+                const firstCertificate = certificates[0];
+                if (!firstCertificate) {
+                    consola.error(`No certificate found with name '${name}' and platform '${platform}'.`);
+                    process.exit(1);
+                }
+                certificateId = firstCertificate.id;
+            }
+            else if (isInteractive()) {
+                if (!platform) {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    platform = await prompt('Select the platform:', {
+                        type: 'select',
+                        options: [
+                            { label: 'Android', value: 'android' },
+                            { label: 'iOS', value: 'ios' },
+                            { label: 'Web', value: 'web' },
+                        ],
+                    });
+                }
+                const certificates = await appCertificatesService.findAll({ appId, platform });
+                if (!certificates.length) {
+                    consola.error('No certificates found for this app. Create one first.');
+                    process.exit(1);
+                }
+                // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                certificateId = await prompt('Select the certificate to delete:', {
+                    type: 'select',
+                    options: certificates.map((cert) => ({ label: cert.name, value: cert.id })),
+                });
+            }
+            else {
+                consola.error('You must provide the certificate ID or --name and --platform when running in non-interactive environment.');
+                process.exit(1);
+            }
+        }
+        if (!options.yes && isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to delete this certificate?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appCertificatesService.delete({ appId, certificateId });
+        consola.success('Certificate deleted successfully.');
+    }),
+});

package/dist/commands/apps/certificates/get.js

@@ -0,0 +1,80 @@
+import appCertificatesService from '../../../services/app-certificates.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Get an existing app certificate.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        certificateId: z.string().optional().describe('ID of the certificate.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        name: z.string().optional().describe('Name of the certificate.'),
+        platform: z
+            .enum(['android', 'ios', 'web'])
+            .optional()
+            .describe('Platform of the certificate (android, ios, web).'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, certificateId, name, platform } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!certificateId) {
+            if (name && platform) {
+                const certificates = await appCertificatesService.findAll({ appId, name, platform });
+                const firstCertificate = certificates[0];
+                if (!firstCertificate) {
+                    consola.error(`No certificate found with name '${name}' and platform '${platform}'.`);
+                    process.exit(1);
+                }
+                certificateId = firstCertificate.id;
+            }
+            else if (isInteractive()) {
+                if (!platform) {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    platform = await prompt('Select the platform:', {
+                        type: 'select',
+                        options: [
+                            { label: 'Android', value: 'android' },
+                            { label: 'iOS', value: 'ios' },
+                            { label: 'Web', value: 'web' },
+                        ],
+                    });
+                }
+                const certificates = await appCertificatesService.findAll({ appId, platform });
+                if (!certificates.length) {
+                    consola.error('No certificates found for this app. Create one first.');
+                    process.exit(1);
+                }
+                // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                certificateId = await prompt('Select the certificate:', {
+                    type: 'select',
+                    options: certificates.map((cert) => ({ label: cert.name, value: cert.id })),
+                });
+            }
+            else {
+                consola.error('You must provide the certificate ID or --name and --platform when running in non-interactive environment.');
+                process.exit(1);
+            }
+        }
+        const certificate = await appCertificatesService.findOneById({
+            appId,
+            certificateId,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(certificate, null, 2));
+        }
+        else {
+            console.table(certificate);
+            consola.success('Certificate retrieved successfully.');
+        }
+    }),
+});

package/dist/commands/apps/certificates/list.js

@@ -0,0 +1,43 @@
+import appCertificatesService from '../../../services/app-certificates.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Retrieve a list of existing app certificates.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        limit: z.coerce.number().optional().describe('Limit for pagination.'),
+        offset: z.coerce.number().optional().describe('Offset for pagination.'),
+        platform: z.enum(['android', 'ios', 'web']).optional().describe('Filter by platform.'),
+        type: z.enum(['development', 'production']).optional().describe('Filter by type.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, json, limit, offset, platform, type } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        const certificates = await appCertificatesService.findAll({
+            appId,
+            limit,
+            offset,
+            platform,
+            type,
+        });
+        if (json) {
+            console.log(JSON.stringify(certificates, null, 2));
+        }
+        else {
+            console.table(certificates);
+            consola.success('Certificates retrieved successfully.');
+        }
+    }),
+});

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

@@ -0,0 +1,50 @@
+import appCertificatesService from '../../../services/app-certificates.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Update an existing app certificate.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        certificateId: z.string().optional().describe('ID of the certificate.'),
+        keyAlias: z.string().optional().describe('Key alias for the certificate.'),
+        keyPassword: z.string().optional().describe('Key password for the certificate.'),
+        name: z.string().optional().describe('Name of the certificate.'),
+        password: z.string().optional().describe('Password for the certificate.'),
+        type: z
+            .enum(['development', 'production'])
+            .optional()
+            .describe('Type of the certificate (development, production).'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId, certificateId, keyAlias, keyPassword, name, password, type } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        if (!certificateId) {
+            if (!isInteractive()) {
+                consola.error('You must provide the certificate ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            certificateId = await prompt('Enter the certificate ID:', { type: 'text' });
+        }
+        await appCertificatesService.update({
+            appId,
+            certificateId,
+            name,
+            type,
+            password,
+            keyAlias,
+            keyPassword,
+        });
+        consola.success('Certificate updated successfully.');
+    }),
+});

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

@@ -25,12 +25,8 @@ export default defineCommand({
     })),
     action: withAuth(async (options, args) => {
         let { appId, expiresInDays, ignoreErrors, name, protected: _protected } = options;
-        // Calculate the expiration date
-        let expiresAt;
         if (expiresInDays) {
-            const expiresAtDate = new Date();
-            expiresAtDate.setDate(expiresAtDate.getDate() + expiresInDays);
-            expiresAt = expiresAtDate.toISOString();
+            consola.warn('The `--expires-in-days` option is deprecated and will be removed in a future version. Channel expiration is now managed by the data retention policy of your organization billing plan.');
         }
         // Validate the app ID
         if (!appId) {
@@ -54,7 +50,6 @@ export default defineCommand({
                 appId,
                 protected: _protected,
                 name,
-                expiresAt,
             });
             consola.info(`Channel ID: ${response.id}`);
             consola.success('Channel created successfully.');

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

@@ -109,29 +109,24 @@ describe('apps-channels-create', () => {
         await expect(createChannelCommand.action(options, undefined)).rejects.toThrow();
         expect(scope.isDone()).toBe(true);
     });
-    it('should create channel with expiresInDays option', async () => {
+    it('should show warning when expiresInDays option is used', async () => {
         const appId = 'app-123';
         const channelName = 'production';
         const expiresInDays = 30;
         const channelId = 'channel-456';
         const testToken = 'test-token';
         const options = { appId, name: channelName, expiresInDays };
-        // Calculate expected expiration date
-        const expectedExpiresAt = new Date();
-        expectedExpiresAt.setDate(expectedExpiresAt.getDate() + expiresInDays);
         const scope = nock(DEFAULT_API_BASE_URL)
-            .post(`/v1/apps/${appId}/channels`, (body) => {
-            // Verify the request includes expiresAt and it's approximately correct (within 1 minute)
-            const actualExpiresAt = new Date(body.expiresAt);
-            const timeDiff = Math.abs(actualExpiresAt.getTime() - expectedExpiresAt.getTime());
-            const oneMinute = 60 * 1000;
-            return (body.appId === appId && body.name === channelName && body.protected === undefined && timeDiff < oneMinute);
+            .post(`/v1/apps/${appId}/channels`, {
+            appId,
+            name: channelName,
+            protected: undefined,
         })
             .matchHeader('Authorization', `Bearer ${testToken}`)
             .reply(201, { id: channelId, name: channelName });
         await createChannelCommand.action(options, undefined);
         expect(scope.isDone()).toBe(true);
+        expect(mockConsola.warn).toHaveBeenCalledWith('The `--expires-in-days` option is deprecated and will be removed in a future version. Channel expiration is now managed by the data retention policy of your organization billing plan.');
         expect(mockConsola.success).toHaveBeenCalledWith('Channel created successfully.');
-        expect(mockConsola.info).toHaveBeenCalledWith(`Channel ID: ${channelId}`);
     });
 });