@capawesome/cli 4.6.0 → 4.7.0

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

@@ -2,16 +2,15 @@ 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 { unescapeAnsi } from '../../../utils/ansi.js';
 import { withAuth } from '../../../utils/auth.js';
 import { isInteractive } from '../../../utils/environment.js';
+import { waitForJobCompletion } from '../../../utils/job.js';
 import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
-import { wait } from '../../../utils/wait.js';
 import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Create a new app deployment.',
+    description: 'Create a new app deployment on Capawesome Cloud.',
     options: defineOptions(z.object({
         appId: z
             .uuid({
@@ -159,80 +158,9 @@ export default defineCommand({
         // Wait for deployment job to complete by default, unless --detached flag is set
         const shouldWait = !options.detached && build.platform !== 'web';
         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);
-                }
-            }
+            await waitForJobCompletion({ jobId: response.jobId });
+            consola.success('Deployment completed successfully.');
+            process.exit(0);
         }
     }),
 });

package/dist/commands/apps/devices/forcechannel.js

@@ -10,11 +10,11 @@ export default defineCommand({
     description: 'Force a device to use a specific channel.',
     options: defineOptions(z.object({
         appId: z.string().uuid({ message: 'App ID must be a UUID.' }).optional().describe('ID of the app.'),
-        deviceId: z.string().optional().describe('ID of the device.'),
+        deviceId: z.array(z.string()).optional().describe('ID of the device. Can be specified multiple times.'),
         channel: z.string().optional().describe('Name of the channel to force.'),
     })),
     action: withAuth(async (options, args) => {
-        let { appId, deviceId, channel } = options;
+        let { appId, deviceId: deviceIds, channel } = options;
         if (!appId) {
             if (!isInteractive()) {
                 consola.error('You must provide an app ID when running in non-interactive environment.');
@@ -23,14 +23,15 @@ export default defineCommand({
             const organizationId = await promptOrganizationSelection();
             appId = await promptAppSelection(organizationId);
         }
-        if (!deviceId) {
+        if (!deviceIds || deviceIds.length === 0) {
             if (!isInteractive()) {
                 consola.error('You must provide the device ID when running in non-interactive environment.');
                 process.exit(1);
             }
-            deviceId = await prompt('Enter the device ID:', {
+            const deviceId = await prompt('Enter the device ID:', {
                 type: 'text',
             });
+            deviceIds = [deviceId];
         }
         if (!channel) {
             if (!isInteractive()) {
@@ -56,11 +57,12 @@ export default defineCommand({
             consola.error('Channel ID not found.');
             process.exit(1);
         }
-        await appDevicesService.update({
+        await appDevicesService.updateMany({
             appId,
-            deviceId,
+            deviceIds,
             forcedAppChannelId: channelId,
         });
-        consola.success('Device forced to channel successfully.');
+        const deviceCount = deviceIds.length;
+        consola.success(`${deviceCount === 1 ? 'Device' : `${deviceCount} devices`} forced to channel successfully.`);
     }),
 });

package/dist/commands/apps/devices/unforcechannel.js

@@ -9,10 +9,10 @@ export default defineCommand({
     description: 'Remove the forced channel from a device.',
     options: defineOptions(z.object({
         appId: z.string().uuid({ message: 'App ID must be a UUID.' }).optional().describe('ID of the app.'),
-        deviceId: z.string().optional().describe('ID of the device.'),
+        deviceId: z.array(z.string()).optional().describe('ID of the device. Can be specified multiple times.'),
     })),
     action: withAuth(async (options, args) => {
-        let { appId, deviceId } = options;
+        let { appId, deviceId: deviceIds } = options;
         if (!appId) {
             if (!isInteractive()) {
                 consola.error('You must provide an app ID when running in non-interactive environment.');
@@ -21,20 +21,22 @@ export default defineCommand({
             const organizationId = await promptOrganizationSelection();
             appId = await promptAppSelection(organizationId);
         }
-        if (!deviceId) {
+        if (!deviceIds || deviceIds.length === 0) {
             if (!isInteractive()) {
                 consola.error('You must provide the device ID when running in non-interactive environment.');
                 process.exit(1);
             }
-            deviceId = await prompt('Enter the device ID:', {
+            const deviceId = await prompt('Enter the device ID:', {
                 type: 'text',
             });
+            deviceIds = [deviceId];
         }
-        await appDevicesService.update({
+        await appDevicesService.updateMany({
             appId,
-            deviceId,
+            deviceIds,
             forcedAppChannelId: null,
         });
-        consola.success('Forced channel removed from device successfully.');
+        const deviceCount = deviceIds.length;
+        consola.success(`Forced channel removed from ${deviceCount === 1 ? 'device' : `${deviceCount} devices`} successfully.`);
     }),
 });

package/dist/commands/apps/link.js

@@ -0,0 +1,34 @@
+import appsService from '../../services/apps.js';
+import { withAuth } from '../../utils/auth.js';
+import { isInteractive } from '../../utils/environment.js';
+import { getGitRemoteInfo } from '../../utils/git.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: 'Connect a git repository to an app.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide the app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        const gitRemoteInfo = getGitRemoteInfo();
+        await appsService.linkRepository({
+            appId,
+            ownerSlug: gitRemoteInfo.ownerSlug,
+            provider: gitRemoteInfo.provider,
+            repositorySlug: gitRemoteInfo.repositorySlug,
+            projectSlug: gitRemoteInfo.projectSlug,
+        });
+        consola.success('Repository connected successfully.');
+    }),
+});

package/dist/commands/apps/link.test.js

@@ -0,0 +1,94 @@
+import { DEFAULT_API_BASE_URL } from '../../config/consts.js';
+import authorizationService from '../../services/authorization-service.js';
+import { promptAppSelection, promptOrganizationSelection } from '../../utils/prompt.js';
+import userConfig from '../../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import linkCommand from './link.js';
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => true,
+}));
+vi.mock('@/utils/git.js', () => ({
+    getGitRemoteInfo: () => ({
+        ownerSlug: 'capawesome-team',
+        provider: 'github',
+        repositorySlug: 'cli',
+    }),
+}));
+describe('apps-link', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPromptOrganizationSelection = vi.mocked(promptOrganizationSelection);
+    const mockPromptAppSelection = vi.mocked(promptAppSelection);
+    const mockConsola = vi.mocked(consola);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should link repository with provided app ID', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await linkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
+    });
+    it('should prompt for organization and app when app ID is not provided', async () => {
+        const appId = 'app-123';
+        const orgId = 'org-1';
+        const testToken = 'test-token';
+        const options = {};
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await linkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPromptOrganizationSelection).toHaveBeenCalled();
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Git provider not connected' });
+        await expect(linkCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/liveupdates/bundle.js

@@ -1,5 +1,5 @@
 import { isInteractive } from '../../../utils/environment.js';
-import { fileExistsAtPath, isDirectory } from '../../../utils/file.js';
+import { directoryContainsSourceMaps, directoryContainsSymlinks, fileExistsAtPath, isDirectory } from '../../../utils/file.js';
 import { generateManifestJson } from '../../../utils/manifest.js';
 import { prompt } from '../../../utils/prompt.js';
 import zip from '../../../utils/zip.js';
@@ -9,7 +9,7 @@ import fs from 'fs';
 import pathModule from 'path';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Generate manifest file and compress web assets into a bundle.zip file.',
+    description: 'Generate manifest file and compress locally built web assets into a bundle.zip file.',
     options: defineOptions(z.object({
         inputPath: z.string().optional().describe('Path to the web assets directory.'),
         outputPath: z
@@ -62,6 +62,16 @@ export default defineCommand({
             consola.error(`Directory must contain an index.html file: ${inputPath}`);
             process.exit(1);
         }
+        // Check for symlinks
+        const containsSymlinks = await directoryContainsSymlinks(inputPath);
+        if (containsSymlinks) {
+            consola.warn('Symbolic links were detected in the specified path. Symbolic links are skipped during bundling.');
+        }
+        // Check for source maps
+        const containsSourceMaps = await directoryContainsSourceMaps(inputPath);
+        if (containsSourceMaps) {
+            consola.warn('Source map files were detected in the specified path. Source maps should not be distributed to end users as they expose your original source code and increase the download size. Consider excluding source map files from your build output.');
+        }
         // 2. Output path resolution
         if (!outputPath) {
             outputPath = './bundle.zip';

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

@@ -0,0 +1,293 @@
+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 appDeploymentsService from '../../../services/app-deployments.js';
+import appEnvironmentsService from '../../../services/app-environments.js';
+import { parseKeyValuePairs } from '../../../utils/app-environments.js';
+import { withAuth } from '../../../utils/auth.js';
+import { parseCustomProperties } from '../../../utils/custom-properties.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { waitForJobCompletion } from '../../../utils/job.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import zip from '../../../utils/zip.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new live update by building and deploying web assets using Capawesome Cloud Runners.',
+    options: defineOptions(z.object({
+        androidEq: z.string().optional().describe('The exact Android versionCode for the live update.'),
+        androidMax: z.string().optional().describe('The maximum Android versionCode for the live update.'),
+        androidMin: z.string().optional().describe('The minimum Android versionCode for the live update.'),
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID to create the live update for.'),
+        certificate: z.string().optional().describe('The name of the certificate to use for the build.'),
+        channel: z
+            .array(z.string())
+            .optional()
+            .describe('The name of the channel to deploy to. Can be specified multiple times.'),
+        customProperty: z
+            .array(z.string().min(1).max(100))
+            .max(10)
+            .optional()
+            .describe('A custom property to assign to the build. Must be in the format `key=value`. Can be specified multiple times.'),
+        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.'),
+        iosEq: z.string().optional().describe('The exact iOS CFBundleVersion for the live update.'),
+        iosMax: z.string().optional().describe('The maximum iOS CFBundleVersion for the live update.'),
+        iosMin: z.string().optional().describe('The minimum iOS CFBundleVersion for the live update.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        path: z.string().optional().describe('Path to local source files to upload.'),
+        rolloutPercentage: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe('The rollout percentage for the deployment (0-100). Default: 100.'),
+        stack: z
+            .enum(['macos-sequoia', 'macos-tahoe'], {
+            message: 'Build stack must be either `macos-sequoia` or `macos-tahoe`.',
+        })
+            .optional()
+            .describe('The build stack to use for the build process.'),
+        url: z.string().optional().describe('URL to a zip file to use as build source.'),
+        variable: z
+            .array(z.string())
+            .optional()
+            .describe('Ad hoc environment variable in key=value format. Can be specified multiple times.'),
+        variableFile: z
+            .string()
+            .optional()
+            .describe('Path to a file containing ad hoc environment variables in .env format.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompts.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options) => {
+        let { appId, certificate, channel, gitRef, environment, json, stack, path: sourcePath, url } = options;
+        // Validate that path, url, and gitRef cannot be used together
+        if (sourcePath && gitRef) {
+            consola.error('The --path and --git-ref flags cannot be used together.');
+            process.exit(1);
+        }
+        if (url && gitRef) {
+            consola.error('The --url and --git-ref flags cannot be used together.');
+            process.exit(1);
+        }
+        if (url && sourcePath) {
+            consola.error('The --url and --path flags cannot be used together.');
+            process.exit(1);
+        }
+        // Validate url if provided
+        if (url) {
+            consola.warn('The --url option is experimental and may change in the future.');
+        }
+        // Validate path if provided
+        if (sourcePath) {
+            consola.warn('The --path option is experimental and may change in the future.');
+            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()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection({ allowCreate: true });
+            appId = await promptAppSelection(organizationId, { allowCreate: true });
+        }
+        // Prompt for git ref if not provided and no path or url specified
+        if (!sourcePath && !url && !gitRef) {
+            if (!isInteractive()) {
+                consola.error('You must provide a git ref, path, or url 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);
+            }
+        }
+        // Prompt for channel if not provided
+        if (!channel || channel.length === 0) {
+            if (!isInteractive()) {
+                consola.error('You must provide at least one channel when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const channelName = await prompt('Enter the channel name to deploy to:', {
+                type: 'text',
+            });
+            if (!channelName) {
+                consola.error('You must provide a channel.');
+                process.exit(1);
+            }
+            channel = [channelName];
+        }
+        // Prompt for environment if not provided
+        if (!environment && !options.yes && isInteractive()) {
+            // @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 && !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',
+                initial: false,
+            });
+            if (selectCertificate) {
+                const certificates = await appCertificatesService.findAll({ appId, platform: 'web' });
+                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 })),
+                    });
+                }
+            }
+        }
+        // Parse ad hoc environment variables from inline and file
+        const variablesMap = new Map();
+        if (options.variableFile) {
+            const fileContent = await fs.readFile(options.variableFile, 'utf-8');
+            const fileVariables = parseKeyValuePairs(fileContent);
+            fileVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        if (options.variable) {
+            const inlineVariables = parseKeyValuePairs(options.variable.join('\n'));
+            inlineVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        const adHocEnvironmentVariables = variablesMap.size > 0 ? Object.fromEntries(variablesMap) : undefined;
+        // Create build source from URL if provided
+        let appBuildSourceId;
+        if (url) {
+            consola.start('Creating build source from URL...');
+            const appBuildSource = await appBuildSourcesService.createFromUrl({ appId, fileUrl: url });
+            appBuildSourceId = appBuildSource.id;
+            consola.success('Build source created successfully.');
+        }
+        // Upload source files if path is provided
+        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.createFromFile({
+                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 web build
+        consola.start('Creating build...');
+        const response = await appBuildsService.create({
+            adHocEnvironmentVariables,
+            appBuildSourceId,
+            appCertificateName: certificate,
+            appEnvironmentName: environment,
+            appId,
+            stack,
+            gitRef,
+            platform: 'web',
+        });
+        consola.info(`Build ID: ${response.id}`);
+        consola.info(`Build Number: ${response.numberAsString}`);
+        consola.info(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${response.id}`);
+        consola.success('Build created successfully.');
+        // Wait for build to complete
+        await waitForJobCompletion({ jobId: response.jobId });
+        consola.success('Build completed successfully.');
+        console.log();
+        // Update build with custom properties and version constraints if any are provided
+        const customProperties = parseCustomProperties(options.customProperty);
+        const hasUpdateFields = customProperties ||
+            options.androidMin ||
+            options.androidMax ||
+            options.androidEq ||
+            options.iosMin ||
+            options.iosMax ||
+            options.iosEq;
+        if (hasUpdateFields) {
+            consola.start('Updating build...');
+            await appBuildsService.update({
+                appId,
+                appBuildId: response.id,
+                customProperties,
+                minAndroidAppVersionCode: options.androidMin,
+                maxAndroidAppVersionCode: options.androidMax,
+                eqAndroidAppVersionCode: options.androidEq,
+                minIosAppVersionCode: options.iosMin,
+                maxIosAppVersionCode: options.iosMax,
+                eqIosAppVersionCode: options.iosEq,
+            });
+            consola.success('Build updated successfully.');
+        }
+        // Deploy to channels
+        const rolloutPercentage = (options.rolloutPercentage ?? 100) / 100;
+        const deploymentIds = [];
+        for (const channelName of channel) {
+            consola.start(`Creating deployment for channel "${channelName}"...`);
+            const deployment = await appDeploymentsService.create({
+                appId,
+                appBuildId: response.id,
+                appChannelName: channelName,
+                rolloutPercentage,
+            });
+            deploymentIds.push(deployment.id);
+            consola.info(`Deployment ID: ${deployment.id}`);
+            consola.info(`Deployment URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/deployments/${deployment.id}`);
+            consola.success('Deployment created successfully.');
+        }
+        // Output JSON if json flag is set
+        if (json) {
+            console.log(JSON.stringify({
+                buildId: response.id,
+                buildNumberAsString: response.numberAsString,
+                deploymentIds,
+            }, null, 2));
+        }
+    }),
+});