@capawesome/cli 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.
 
+## [3.4.0](https://github.com/capawesome-team/cli/compare/v3.3.0...v3.4.0) (2025-11-19)
+
+
+### Features
+
+* support builds and deployments ([#89](https://github.com/capawesome-team/cli/issues/89)) ([71be7b0](https://github.com/capawesome-team/cli/commit/71be7b0b69c59bd5d7e123fe37b30044a47f7afc))
+
 ## [3.3.0](https://github.com/capawesome-team/cli/compare/v3.2.2...v3.3.0) (2025-10-03)
 
 

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

@@ -0,0 +1,106 @@
+import appBuildsService from '../../../services/app-builds.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import jobsService from '../../../services/jobs.js';
+import organizationsService from '../../../services/organizations.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { hasTTY } from 'std-env';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Cancel an app build.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID the build belongs to.'),
+        buildId: z
+            .uuid({
+            message: 'Build ID must be a UUID.',
+        })
+            .optional()
+            .describe('Build ID to cancel.'),
+    })),
+    action: async (options) => {
+        let { appId, buildId } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!hasTTY) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before canceling a build.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to cancel a build.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to cancel a build.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (apps.length === 0) {
+                consola.error('You must create an app before canceling a build.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to cancel a build for:', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+            if (!appId) {
+                consola.error('You must select an app to cancel a build for.');
+                process.exit(1);
+            }
+        }
+        // Prompt for build ID if not provided
+        if (!buildId) {
+            if (!hasTTY) {
+                consola.error('You must provide a build ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const builds = await appBuildsService.findAll({ appId });
+            if (builds.length === 0) {
+                consola.error('No builds found for this app.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            buildId = await prompt('Which build do you want to cancel:', {
+                type: 'select',
+                options: builds.map((build) => ({
+                    label: `Build #${build.numberAsString || build.id} (${build.platform} - ${build.type})`,
+                    value: build.id,
+                })),
+            });
+            if (!buildId) {
+                consola.error('You must select a build to cancel.');
+                process.exit(1);
+            }
+        }
+        // Fetch the build details to get the job ID
+        consola.start('Fetching build details...');
+        const build = await appBuildsService.findOne({ appId, appBuildId: buildId });
+        // Cancel the job
+        consola.start('Canceling build...');
+        await jobsService.update({
+            jobId: build.jobId,
+            dto: { status: 'canceled' },
+        });
+        consola.success('Build successfully canceled.');
+    },
+});

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

@@ -0,0 +1,359 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appBuildsService from '../../../services/app-builds.js';
+import appCertificatesService from '../../../services/app-certificates.js';
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { unescapeAnsi } from '../../../utils/ansi.js';
+import { prompt } from '../../../utils/prompt.js';
+import { wait } from '../../../utils/wait.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs/promises';
+import path from 'path';
+import { hasTTY } from 'std-env';
+import { z } from 'zod';
+const IOS_BUILD_TYPES = ['simulator', 'development', 'ad-hoc', 'app-store', 'enterprise'];
+const ANDROID_BUILD_TYPES = ['debug', 'release'];
+export default defineCommand({
+    description: 'Create a new app build.',
+    options: defineOptions(z.object({
+        aab: z
+            .union([z.boolean(), z.string()])
+            .optional()
+            .describe('Download the generated AAB file (Android only). Optionally provide a file path.'),
+        apk: z
+            .union([z.boolean(), z.string()])
+            .optional()
+            .describe('Download the generated APK file (Android only). Optionally provide a file path.'),
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID to create the build for.'),
+        certificate: z.string().optional().describe('The name of the certificate to use for the build.'),
+        detached: z
+            .boolean()
+            .optional()
+            .describe('Exit immediately after creating the build without waiting for completion.'),
+        environment: z.string().optional().describe('The name of the environment to use for the build.'),
+        gitRef: z.string().optional().describe('The Git reference (branch, tag, or commit SHA) to build.'),
+        ipa: z
+            .union([z.boolean(), z.string()])
+            .optional()
+            .describe('Download the generated IPA file (iOS only). Optionally provide a file path.'),
+        platform: z
+            .enum(['ios', 'android'], {
+            message: 'Platform must be either `ios` or `android`.',
+        })
+            .optional()
+            .describe('The platform for the build. Supported values are `ios` and `android`.'),
+        type: z
+            .string()
+            .optional()
+            .describe('The type of build. For iOS, supported values are `simulator`, `development`, `ad-hoc`, `app-store`, and `enterprise`. For Android, supported values are `debug` and `release`.'),
+    })),
+    action: async (options) => {
+        let { appId, platform, type, gitRef, environment, certificate } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
+        // Validate that detached flag cannot be used with artifact flags
+        if (options.detached && (options.apk || options.aab || options.ipa)) {
+            consola.error('The --detached flag cannot be used with --apk, --aab, or --ipa flags.');
+            process.exit(1);
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!hasTTY) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before creating a build.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to create a build.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to create a build.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (apps.length === 0) {
+                consola.error('You must create an app before creating a build.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to create a build for:', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+            if (!appId) {
+                consola.error('You must select an app to create a build for.');
+                process.exit(1);
+            }
+        }
+        // Prompt for platform if not provided
+        if (!platform) {
+            if (!hasTTY) {
+                consola.error('You must provide a 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 for the build:', {
+                type: 'select',
+                options: [
+                    { label: 'Android', value: 'android' },
+                    { label: 'iOS', value: 'ios' },
+                ],
+            });
+            if (!platform) {
+                consola.error('You must select a platform.');
+                process.exit(1);
+            }
+        }
+        // Prompt for git ref if not provided
+        if (!gitRef) {
+            if (!hasTTY) {
+                consola.error('You must provide a git ref when running in non-interactive environment.');
+                process.exit(1);
+            }
+            gitRef = await prompt('Enter the Git reference (branch, tag, or commit SHA):', {
+                type: 'text',
+            });
+            if (!gitRef) {
+                consola.error('You must provide a git ref.');
+                process.exit(1);
+            }
+        }
+        // Set default type based on platform if not provided
+        if (!type) {
+            type = platform === 'android' ? 'debug' : 'simulator';
+        }
+        // Validate type based on platform
+        if (platform === 'ios' && !IOS_BUILD_TYPES.includes(type)) {
+            consola.error(`Invalid build type for iOS. Supported values are: ${IOS_BUILD_TYPES.map((t) => `\`${t}\``).join(', ')}.`);
+            process.exit(1);
+        }
+        if (platform === 'android' && !ANDROID_BUILD_TYPES.includes(type)) {
+            consola.error(`Invalid build type for Android. Supported values are: ${ANDROID_BUILD_TYPES.map((t) => `\`${t}\``).join(', ')}.`);
+            process.exit(1);
+        }
+        // Prompt for environment if not provided
+        if (!environment && hasTTY) {
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectEnvironment = await prompt('Do you want to select an environment?', {
+                type: 'confirm',
+                initial: false,
+            });
+            if (selectEnvironment) {
+                const environments = await appEnvironmentsService.findAll({ appId });
+                if (environments.length === 0) {
+                    consola.warn('No environments found for this app.');
+                }
+                else {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    environment = await prompt('Select the environment for the build:', {
+                        type: 'select',
+                        options: environments.map((env) => ({ label: env.name, value: env.name })),
+                    });
+                }
+            }
+        }
+        // Prompt for certificate if not provided
+        if (!certificate && hasTTY) {
+            // @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',
+                initial: false,
+            });
+            if (selectCertificate) {
+                const certificates = await appCertificatesService.findAll({ appId, platform });
+                if (certificates.length === 0) {
+                    consola.warn('No certificates found for this app.');
+                }
+                else {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    certificate = await prompt('Select the certificate for the build:', {
+                        type: 'select',
+                        options: certificates.map((cert) => ({ label: cert.name, value: cert.name })),
+                    });
+                }
+            }
+        }
+        // Create the app build
+        consola.start('Creating build...');
+        const response = await appBuildsService.create({
+            appCertificateName: certificate,
+            appEnvironmentName: environment,
+            appId,
+            gitRef,
+            platform,
+            type,
+        });
+        consola.success(`Build created successfully.`);
+        consola.info(`Build Number: ${response.numberAsString}`);
+        consola.info(`Build ID: ${response.id}`);
+        consola.info(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${response.id}`);
+        // Wait for build job to complete by default, unless --detached flag is set
+        const shouldWait = !options.detached;
+        if (shouldWait) {
+            let lastPrintedLogNumber = 0;
+            let isWaitingForStart = true;
+            // Poll build status until completion
+            while (true) {
+                try {
+                    const build = await appBuildsService.findOne({
+                        appId,
+                        appBuildId: response.id,
+                        relations: 'appBuildArtifacts,job,job.jobLogs',
+                    });
+                    if (!build.job) {
+                        await wait(3000);
+                        continue;
+                    }
+                    const jobStatus = build.job.status;
+                    // Show spinner while queued or pending
+                    if (jobStatus === 'queued' || jobStatus === 'pending') {
+                        if (isWaitingForStart) {
+                            consola.start(`Waiting for build to start (status: ${jobStatus})...`);
+                        }
+                        await wait(3000);
+                        continue;
+                    }
+                    // Stop spinner when job moves to in_progress
+                    if (isWaitingForStart && jobStatus === 'in_progress') {
+                        isWaitingForStart = false;
+                        consola.success('Build started...');
+                    }
+                    // Print new logs
+                    if (build.job.jobLogs && build.job.jobLogs.length > 0) {
+                        const newLogs = build.job.jobLogs
+                            .filter((log) => log.number > lastPrintedLogNumber)
+                            .sort((a, b) => a.number - b.number);
+                        for (const log of newLogs) {
+                            console.log(unescapeAnsi(log.payload));
+                            lastPrintedLogNumber = log.number;
+                        }
+                    }
+                    // Handle terminal states
+                    if (jobStatus === 'succeeded' ||
+                        jobStatus === 'failed' ||
+                        jobStatus === 'canceled' ||
+                        jobStatus === 'rejected' ||
+                        jobStatus === 'timed_out') {
+                        console.log(); // New line for better readability
+                        if (jobStatus === 'succeeded') {
+                            consola.success('Build completed successfully.');
+                            console.log(); // New line for better readability
+                            // Download artifacts if flags are set
+                            if (options.apk && platform === 'android') {
+                                await handleArtifactDownload({
+                                    appId,
+                                    buildId: response.id,
+                                    buildArtifacts: build.appBuildArtifacts,
+                                    artifactType: 'apk',
+                                    filePath: typeof options.apk === 'string' ? options.apk : undefined,
+                                });
+                            }
+                            if (options.aab && platform === 'android') {
+                                await handleArtifactDownload({
+                                    appId,
+                                    buildId: response.id,
+                                    buildArtifacts: build.appBuildArtifacts,
+                                    artifactType: 'aab',
+                                    filePath: typeof options.aab === 'string' ? options.aab : undefined,
+                                });
+                            }
+                            if (options.ipa && platform === 'ios') {
+                                await handleArtifactDownload({
+                                    appId,
+                                    buildId: response.id,
+                                    buildArtifacts: build.appBuildArtifacts,
+                                    artifactType: 'ipa',
+                                    filePath: typeof options.ipa === 'string' ? options.ipa : undefined,
+                                });
+                            }
+                            process.exit(0);
+                        }
+                        else if (jobStatus === 'failed') {
+                            consola.error('Build failed.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'canceled') {
+                            consola.warn('Build was canceled.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'rejected') {
+                            consola.error('Build was rejected.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'timed_out') {
+                            consola.error('Build timed out.');
+                            process.exit(1);
+                        }
+                    }
+                    // Wait before next poll (3 seconds)
+                    await wait(3000);
+                }
+                catch (error) {
+                    consola.error('Error polling build status:', error);
+                    process.exit(1);
+                }
+            }
+        }
+    },
+});
+/**
+ * Download a build artifact (APK, AAB, or IPA).
+ */
+const handleArtifactDownload = async (options) => {
+    const { appId, buildId, buildArtifacts, artifactType, filePath } = options;
+    try {
+        const artifactTypeUpper = artifactType.toUpperCase();
+        consola.start(`Downloading ${artifactTypeUpper}...`);
+        // Find the artifact
+        const artifact = buildArtifacts?.find((artifact) => artifact.type === artifactType);
+        if (!artifact) {
+            consola.warn(`No ${artifactTypeUpper} artifact found for this build.`);
+            return;
+        }
+        if (artifact.status !== 'ready') {
+            consola.warn(`${artifactTypeUpper} artifact is not ready (status: ${artifact.status}).`);
+            return;
+        }
+        // Download the artifact
+        const artifactData = await appBuildsService.downloadArtifact({
+            appId,
+            appBuildId: buildId,
+            artifactId: artifact.id,
+        });
+        // Determine the file path
+        let outputPath;
+        if (filePath) {
+            // Use provided path (can be relative or absolute)
+            outputPath = path.resolve(filePath);
+        }
+        else {
+            // Default to current working directory with build ID as filename
+            outputPath = path.resolve(`${buildId}.${artifactType}`);
+        }
+        // Save the file
+        await fs.writeFile(outputPath, Buffer.from(artifactData));
+        consola.success(`${artifactTypeUpper} downloaded successfully: ${outputPath}`);
+    }
+    catch (error) {
+        consola.error(`Failed to download ${artifactType.toUpperCase()}:`, error);
+    }
+};

package/dist/commands/apps/deployments/cancel.js

@@ -0,0 +1,111 @@
+import appDeploymentsService from '../../../services/app-deployments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import jobsService from '../../../services/jobs.js';
+import organizationsService from '../../../services/organizations.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { hasTTY } from 'std-env';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Cancel an ongoing app deployment.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID the deployment belongs to.'),
+        deploymentId: z
+            .uuid({
+            message: 'Deployment ID must be a UUID.',
+        })
+            .optional()
+            .describe('Deployment ID to cancel.'),
+    })),
+    action: async (options) => {
+        let { appId, deploymentId } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!hasTTY) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before canceling a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to cancel a deployment.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to cancel a deployment.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (apps.length === 0) {
+                consola.error('You must create an app before canceling a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to cancel a deployment for:', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+            if (!appId) {
+                consola.error('You must select an app to cancel a deployment for.');
+                process.exit(1);
+            }
+        }
+        // Prompt for deployment ID if not provided
+        if (!deploymentId) {
+            if (!hasTTY) {
+                consola.error('You must provide a deployment ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const deployments = await appDeploymentsService.findAll({ appId });
+            if (deployments.length === 0) {
+                consola.error('No deployments found for this app.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            deploymentId = await prompt('Which deployment do you want to cancel:', {
+                type: 'select',
+                options: deployments.map((deployment) => ({
+                    label: `Deployment ${deployment.id}`,
+                    value: deployment.id,
+                })),
+            });
+            if (!deploymentId) {
+                consola.error('You must select a deployment to cancel.');
+                process.exit(1);
+            }
+        }
+        // Get deployment details to retrieve the job ID
+        consola.start('Fetching deployment details...');
+        const deployment = await appDeploymentsService.findOne({
+            appId,
+            appDeploymentId: deploymentId,
+        });
+        // Cancel the job
+        consola.start('Canceling deployment...');
+        await jobsService.update({
+            jobId: deployment.jobId,
+            dto: {
+                status: 'canceled',
+            },
+        });
+        consola.success('Deployment successfully canceled.');
+    },
+});

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

@@ -0,0 +1,222 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appBuildsService from '../../../services/app-builds.js';
+import appDeploymentsService from '../../../services/app-deployments.js';
+import appDestinationsService from '../../../services/app-destinations.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { unescapeAnsi } from '../../../utils/ansi.js';
+import { prompt } from '../../../utils/prompt.js';
+import { wait } from '../../../utils/wait.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { hasTTY } from 'std-env';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new app deployment.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID to create the deployment for.'),
+        buildId: z
+            .uuid({
+            message: 'Build ID must be a UUID.',
+        })
+            .optional()
+            .describe('Build ID to deploy.'),
+        destination: z.string().optional().describe('The name of the destination to deploy to.'),
+        detached: z
+            .boolean()
+            .optional()
+            .describe('Exit immediately after creating the deployment without waiting for completion.'),
+    })),
+    action: async (options) => {
+        let { appId, buildId, destination } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!hasTTY) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before creating a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to create a deployment.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to create a deployment.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (apps.length === 0) {
+                consola.error('You must create an app before creating a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to create a deployment for:', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+            if (!appId) {
+                consola.error('You must select an app to create a deployment for.');
+                process.exit(1);
+            }
+        }
+        // Prompt for build ID if not provided
+        if (!buildId) {
+            if (!hasTTY) {
+                consola.error('You must provide a build ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const builds = await appBuildsService.findAll({ appId });
+            if (builds.length === 0) {
+                consola.error('You must create a build before creating a deployment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            buildId = await prompt('Which build do you want to deploy:', {
+                type: 'select',
+                options: builds.map((build) => ({
+                    label: `Build #${build.numberAsString} (${build.platform} - ${build.type})`,
+                    value: build.id,
+                })),
+            });
+            if (!buildId) {
+                consola.error('You must select a build to deploy.');
+                process.exit(1);
+            }
+        }
+        // Get build information to determine platform
+        const build = await appBuildsService.findOne({ appId, appBuildId: buildId });
+        // Prompt for destination if not provided
+        if (!destination) {
+            if (!hasTTY) {
+                consola.error('You must provide a destination when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const destinations = await appDestinationsService.findAll({
+                appId,
+                platform: build.platform,
+            });
+            if (destinations.length === 0) {
+                consola.error(`You must create a destination for the ${build.platform} platform before creating a deployment.`);
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            destination = await prompt('Which destination do you want to deploy to:', {
+                type: 'select',
+                options: destinations.map((dest) => ({
+                    label: dest.name,
+                    value: dest.name,
+                })),
+            });
+            if (!destination) {
+                consola.error('You must select a destination to deploy to.');
+                process.exit(1);
+            }
+        }
+        // Create the deployment
+        consola.start('Creating deployment...');
+        const response = await appDeploymentsService.create({
+            appId,
+            appBuildId: buildId,
+            appDestinationName: destination,
+        });
+        consola.success('Deployment created successfully.');
+        consola.info(`Deployment ID: ${response.id}`);
+        consola.info(`Deployment URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/deployments/${response.id}`);
+        // Wait for deployment job to complete by default, unless --detached flag is set
+        const shouldWait = !options.detached;
+        if (shouldWait) {
+            let lastPrintedLogNumber = 0;
+            let isWaitingForStart = true;
+            // Poll deployment status until completion
+            while (true) {
+                try {
+                    const deployment = await appDeploymentsService.findOne({
+                        appId,
+                        appDeploymentId: response.id,
+                        relations: 'job,job.jobLogs',
+                    });
+                    if (!deployment.job) {
+                        await wait(3000);
+                        continue;
+                    }
+                    const jobStatus = deployment.job.status;
+                    // Show spinner while queued or pending
+                    if (jobStatus === 'queued' || jobStatus === 'pending') {
+                        if (isWaitingForStart) {
+                            consola.start(`Waiting for deployment to start (status: ${jobStatus})...`);
+                        }
+                        await wait(3000);
+                        continue;
+                    }
+                    // Stop spinner when job moves to in_progress
+                    if (isWaitingForStart && jobStatus === 'in_progress') {
+                        isWaitingForStart = false;
+                        consola.success('Deployment started...');
+                    }
+                    // Print new logs
+                    if (deployment.job.jobLogs && deployment.job.jobLogs.length > 0) {
+                        const newLogs = deployment.job.jobLogs
+                            .filter((log) => log.number > lastPrintedLogNumber)
+                            .sort((a, b) => a.number - b.number);
+                        for (const log of newLogs) {
+                            console.log(unescapeAnsi(log.payload));
+                            lastPrintedLogNumber = log.number;
+                        }
+                    }
+                    // Handle terminal states
+                    if (jobStatus === 'succeeded' ||
+                        jobStatus === 'failed' ||
+                        jobStatus === 'canceled' ||
+                        jobStatus === 'rejected' ||
+                        jobStatus === 'timed_out') {
+                        console.log(); // New line for better readability
+                        if (jobStatus === 'succeeded') {
+                            consola.success('Deployment completed successfully.');
+                            process.exit(0);
+                        }
+                        else if (jobStatus === 'failed') {
+                            consola.error('Deployment failed.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'canceled') {
+                            consola.warn('Deployment was canceled.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'rejected') {
+                            consola.error('Deployment was rejected.');
+                            process.exit(1);
+                        }
+                        else if (jobStatus === 'timed_out') {
+                            consola.error('Deployment timed out.');
+                            process.exit(1);
+                        }
+                    }
+                    // Wait before next poll (3 seconds)
+                    await wait(3000);
+                }
+                catch (error) {
+                    consola.error('Error polling deployment status:', error);
+                    process.exit(1);
+                }
+            }
+        }
+    },
+});

package/dist/index.js

@@ -23,6 +23,8 @@ const config = defineConfig({
         doctor: await import('./commands/doctor.js').then((mod) => mod.default),
         'apps:create': await import('./commands/apps/create.js').then((mod) => mod.default),
         'apps:delete': await import('./commands/apps/delete.js').then((mod) => mod.default),
+        'apps:builds:cancel': await import('./commands/apps/builds/cancel.js').then((mod) => mod.default),
+        'apps:builds:create': await import('./commands/apps/builds/create.js').then((mod) => mod.default),
         'apps:bundles:create': await import('./commands/apps/bundles/create.js').then((mod) => mod.default),
         'apps:bundles:delete': await import('./commands/apps/bundles/delete.js').then((mod) => mod.default),
         'apps:bundles:update': await import('./commands/apps/bundles/update.js').then((mod) => mod.default),
@@ -31,6 +33,8 @@ const config = defineConfig({
         'apps:channels:get': await import('./commands/apps/channels/get.js').then((mod) => mod.default),
         'apps:channels:list': await import('./commands/apps/channels/list.js').then((mod) => mod.default),
         'apps:channels:update': await import('./commands/apps/channels/update.js').then((mod) => mod.default),
+        'apps:deployments:create': await import('./commands/apps/deployments/create.js').then((mod) => mod.default),
+        'apps:deployments:cancel': await import('./commands/apps/deployments/cancel.js').then((mod) => mod.default),
         'apps:devices:delete': await import('./commands/apps/devices/delete.js').then((mod) => mod.default),
         'manifests:generate': await import('./commands/manifests/generate.js').then((mod) => mod.default),
         'organizations:create': await import('./commands/organizations/create.js').then((mod) => mod.default),

package/dist/services/app-builds.js

@@ -0,0 +1,52 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppBuildsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async create(dto) {
+        const { appId, ...bodyData } = dto;
+        const response = await this.httpClient.post(`/v1/apps/${appId}/builds`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async findAll(dto) {
+        const { appId } = dto;
+        const response = await this.httpClient.get(`/v1/apps/${appId}/builds`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async findOne(dto) {
+        const { appId, appBuildId, relations } = dto;
+        const params = {};
+        if (relations) {
+            params.relations = relations;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${appId}/builds/${appBuildId}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+    async downloadArtifact(dto) {
+        const { appId, appBuildId, artifactId } = dto;
+        const response = await this.httpClient.get(`/v1/apps/${appId}/builds/${appBuildId}/artifacts/${artifactId}/download`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            responseType: 'arraybuffer',
+        });
+        return response.data;
+    }
+}
+const appBuildsService = new AppBuildsServiceImpl(httpClient);
+export default appBuildsService;

package/dist/services/app-certificates.js

@@ -0,0 +1,24 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppCertificatesServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async findAll(dto) {
+        const { appId, platform } = dto;
+        const params = {};
+        if (platform) {
+            params.platform = platform;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${appId}/certificates`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+}
+const appCertificatesService = new AppCertificatesServiceImpl(httpClient);
+export default appCertificatesService;

package/dist/services/app-deployments.js

@@ -0,0 +1,48 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppDeploymentsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async create(dto) {
+        const { appId, appBuildId, appDestinationName } = dto;
+        const bodyData = {
+            appBuildId,
+        };
+        if (appDestinationName) {
+            bodyData.appDestinationName = appDestinationName;
+        }
+        const response = await this.httpClient.post(`/v1/apps/${appId}/deployments`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async findAll(dto) {
+        const { appId } = dto;
+        const response = await this.httpClient.get(`/v1/apps/${appId}/deployments`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async findOne(dto) {
+        const { appId, appDeploymentId, relations } = dto;
+        const params = {};
+        if (relations) {
+            params.relations = relations;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${appId}/deployments/${appDeploymentId}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+}
+const appDeploymentsService = new AppDeploymentsServiceImpl(httpClient);
+export default appDeploymentsService;

package/dist/services/app-destinations.js

@@ -0,0 +1,24 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppDestinationsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async findAll(dto) {
+        const { appId, platform } = dto;
+        const params = {};
+        if (platform) {
+            params.platform = platform;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${appId}/destinations`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+}
+const appDestinationsService = new AppDestinationsServiceImpl(httpClient);
+export default appDestinationsService;

package/dist/services/app-environments.js

@@ -0,0 +1,19 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class AppEnvironmentsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async findAll(dto) {
+        const { appId } = dto;
+        const response = await this.httpClient.get(`/v1/apps/${appId}/environments`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+}
+const appEnvironmentsService = new AppEnvironmentsServiceImpl(httpClient);
+export default appEnvironmentsService;

package/dist/services/jobs.js

@@ -0,0 +1,19 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class JobsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async update(options) {
+        const { jobId, dto } = options;
+        const response = await this.httpClient.patch(`/v1/jobs/${jobId}`, dto, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+}
+const jobsService = new JobsServiceImpl(httpClient);
+export default jobsService;

package/dist/types/app-build.js

@@ -0,0 +1 @@
+export {};

package/dist/types/app-certificate.js

@@ -0,0 +1 @@
+export {};

package/dist/types/app-deployment.js

@@ -0,0 +1 @@
+export {};

package/dist/types/app-destination.js

@@ -0,0 +1 @@
+export {};

package/dist/types/app-environment.js

@@ -0,0 +1 @@
+export {};

package/dist/types/job.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ansi.js

@@ -0,0 +1,15 @@
+/**
+ * Unescape ANSI color codes in a string.
+ * Converts escaped sequences like \033 or \x1b to actual escape characters.
+ *
+ * @param str - The string containing escaped ANSI codes.
+ * @returns The string with unescaped ANSI codes.
+ */
+export const unescapeAnsi = (str) => {
+    return str
+        .replace(/\\033/g, '\x1b')
+        .replace(/\\x1b/g, '\x1b')
+        .replace(/\\n/g, '\n')
+        .replace(/\\r/g, '\r')
+        .replace(/\\t/g, '\t');
+};

package/dist/utils/wait.js

@@ -0,0 +1,9 @@
+/**
+ * Wait for a specified number of milliseconds.
+ *
+ * @param ms - The number of milliseconds to wait.
+ * @returns A promise that resolves after the specified time.
+ */
+export const wait = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {