@capawesome/cli 4.4.0 → 4.6.0-dev.0108a83.1774286472

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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.6.0](https://github.com/capawesome-team/cli/compare/v4.5.0...v4.6.0) (2026-03-18)
+
+
+### Features
+
+* add `apps:devices:probe` command ([#129](https://github.com/capawesome-team/cli/issues/129)) ([33607cd](https://github.com/capawesome-team/cli/commit/33607cdb2e65e26c48d114d694b876db3762b8ec))
+
+## [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)
 
 

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

@@ -1,4 +1,5 @@
 import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appBuildSourcesService from '../../../services/app-build-sources.js';
 import appBuildsService from '../../../services/app-builds.js';
 import appCertificatesService from '../../../services/app-certificates.js';
 import appEnvironmentsService from '../../../services/app-environments.js';
@@ -7,6 +8,7 @@ import { withAuth } from '../../../utils/auth.js';
 import { isInteractive } from '../../../utils/environment.js';
 import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
 import { wait } from '../../../utils/wait.js';
+import zip from '../../../utils/zip.js';
 import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import fs from 'fs/promises';
@@ -32,6 +34,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()
@@ -43,6 +47,7 @@ export default defineCommand({
             .optional()
             .describe('Download the generated IPA file (iOS only). Optionally provide a file path.'),
         json: z.boolean().optional().describe('Output in JSON format.'),
+        path: z.string().optional().describe('Path to local source files to upload.'),
         platform: z
             .enum(['ios', 'android', 'web'], {
             message: 'Platform must be either `ios`, `android`, or `web`.',
@@ -66,12 +71,42 @@ export default defineCommand({
         yes: z.boolean().optional().describe('Skip confirmation prompts.'),
     }), { y: 'yes' }),
     action: withAuth(async (options) => {
-        let { appId, platform, type, gitRef, environment, certificate, json, stack } = options;
+        let { appId, platform, type, gitRef, environment, certificate, json, stack, path: sourcePath } = options;
         // Validate that detached flag cannot be used with artifact flags
         if (options.detached && (options.apk || options.aab || options.ipa || options.zip)) {
             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);
+        }
+        // Validate that path and gitRef cannot be used together
+        if (sourcePath && gitRef) {
+            consola.error('The --path and --git-ref flags cannot be used together.');
+            process.exit(1);
+        }
+        // Validate path if provided
+        if (sourcePath) {
+            const resolvedPath = path.resolve(sourcePath);
+            const stat = await fs.stat(resolvedPath).catch(() => null);
+            if (!stat || !stat.isDirectory()) {
+                consola.error('The --path must point to an existing directory.');
+                process.exit(1);
+            }
+            const packageJsonPath = path.join(resolvedPath, 'package.json');
+            const packageJsonStat = await fs.stat(packageJsonPath).catch(() => null);
+            if (!packageJsonStat || !packageJsonStat.isFile()) {
+                consola.error('The directory specified by --path must contain a package.json file.');
+                process.exit(1);
+            }
+        }
         // Prompt for app ID if not provided
         if (!appId) {
             if (!isInteractive()) {
@@ -101,10 +136,10 @@ export default defineCommand({
                 process.exit(1);
             }
         }
-        // Prompt for git ref if not provided
-        if (!gitRef) {
+        // Prompt for git ref if not provided and no path specified
+        if (!sourcePath && !gitRef) {
             if (!isInteractive()) {
-                consola.error('You must provide a git ref when running in non-interactive environment.');
+                consola.error('You must provide a git ref or path when running in non-interactive environment.');
                 process.exit(1);
             }
             gitRef = await prompt('Enter the Git reference (branch, tag, or commit SHA):', {
@@ -133,6 +168,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 +199,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',
@@ -175,9 +220,28 @@ export default defineCommand({
                 }
             }
         }
+        // Upload source files if path is provided
+        let appBuildSourceId;
+        if (sourcePath) {
+            const resolvedPath = path.resolve(sourcePath);
+            consola.start('Zipping source files...');
+            const buffer = await zip.zipFolderWithGitignore(resolvedPath);
+            consola.start('Uploading source files...');
+            const appBuildSource = await appBuildSourcesService.create({
+                appId,
+                fileSizeInBytes: buffer.byteLength,
+                buffer,
+                name: 'source.zip',
+            }, (currentPart, totalParts) => {
+                consola.start(`Uploading source files (${currentPart}/${totalParts})...`);
+            });
+            appBuildSourceId = appBuildSource.id;
+            consola.success('Source files uploaded successfully.');
+        }
         // Create the app build
         consola.start('Creating build...');
         const response = await appBuildsService.create({
+            appBuildSourceId,
             appCertificateName: certificate,
             appEnvironmentName: environment,
             appId,
@@ -288,8 +352,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 +394,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,170 @@
+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. Warn if deprecated --type option is used
+        if (type) {
+            consola.warn('The --type option is deprecated and will be removed in a future version. The certificate type is now detected automatically.');
+        }
+        // 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,
+            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,52 @@
+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' });
+        }
+        if (type) {
+            consola.warn('The --type option is deprecated and will be removed in a future version. The certificate type is now detected automatically.');
+        }
+        await appCertificatesService.update({
+            appId,
+            certificateId,
+            name,
+            password,
+            keyAlias,
+            keyPassword,
+        });
+        consola.success('Certificate updated successfully.');
+    }),
+});