@capawesome/cli 4.6.0-dev.0108a83.1774286472 → 4.6.0-dev.8ae803e.1775035527

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/liveupdates/bundle.js

@@ -1,5 +1,5 @@
 import { isInteractive } from '../../../utils/environment.js';
-import { directoryContainsSourceMaps, 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,11 @@ 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) {

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

@@ -0,0 +1,285 @@
+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.string().optional().describe('The name of the channel to deploy to.'),
+        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) {
+            if (!isInteractive()) {
+                consola.error('You must provide a channel when running in non-interactive environment.');
+                process.exit(1);
+            }
+            channel = await prompt('Enter the channel name to deploy to:', {
+                type: 'text',
+            });
+            if (!channel) {
+                consola.error('You must provide a channel.');
+                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
+            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 channel
+        consola.start('Creating deployment...');
+        const rolloutPercentage = (options.rolloutPercentage ?? 100) / 100;
+        const deployment = await appDeploymentsService.create({
+            appId,
+            appBuildId: response.id,
+            appChannelName: channel,
+            rolloutPercentage,
+        });
+        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,
+                deploymentId: deployment.id,
+            }, null, 2));
+        }
+    }),
+});

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

@@ -0,0 +1,262 @@
+import { DEFAULT_API_BASE_URL, DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.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 createCommand from './create.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('@/utils/job.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => false,
+}));
+describe('apps-liveupdates-create', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockConsola = vi.mocked(consola);
+    const testToken = 'test-token';
+    const appId = '00000000-0000-0000-0000-000000000001';
+    const buildId = '00000000-0000-0000-0000-000000000002';
+    const deploymentId = '00000000-0000-0000-0000-000000000003';
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(testToken);
+        // Mock waitForJobCompletion to resolve immediately
+        const jobUtils = await import('../../../utils/job.js');
+        vi.mocked(jobUtils.waitForJobCompletion).mockResolvedValue({
+            id: 'job-1',
+            status: 'succeeded',
+            createdAt: '2024-01-01T00:00:00Z',
+        });
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should require authentication', async () => {
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(false);
+        const options = { appId, gitRef: 'main', channel: 'production' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must be logged in to run this command. Set the `CAPAWESOME_TOKEN` environment variable or use the `--token` option.');
+    });
+    it('should create a live update with build and deployment', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`, {
+            gitRef: 'main',
+            platform: 'web',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        const deploymentScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`, {
+            appId,
+            appBuildId: buildId,
+            appChannelName: 'production',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(deploymentScope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Build created successfully.');
+        expect(mockConsola.success).toHaveBeenCalledWith('Build completed successfully.');
+        expect(mockConsola.success).toHaveBeenCalledWith('Deployment created successfully.');
+        expect(mockConsola.info).toHaveBeenCalledWith(`Build ID: ${buildId}`);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Deployment ID: ${deploymentId}`);
+    });
+    it('should pass environment and certificate to build', async () => {
+        const options = {
+            appId,
+            gitRef: 'v1.0.0',
+            channel: 'production',
+            environment: 'staging',
+            certificate: 'my-cert',
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`, {
+            gitRef: 'v1.0.0',
+            platform: 'web',
+            appEnvironmentName: 'staging',
+            appCertificateName: 'my-cert',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        const deploymentScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(deploymentScope.isDone()).toBe(true);
+    });
+    it('should pass stack to build', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            stack: 'macos-tahoe',
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`, {
+            gitRef: 'main',
+            platform: 'web',
+            stack: 'macos-tahoe',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        const deploymentScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(deploymentScope.isDone()).toBe(true);
+    });
+    it('should update version constraints when provided', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            androidMin: '10',
+            androidMax: '50',
+            iosEq: '42',
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        const updateScope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/builds/${buildId}`, {
+            minAndroidAppVersionCode: '10',
+            maxAndroidAppVersionCode: '50',
+            eqIosAppVersionCode: '42',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: buildId });
+        const deploymentScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(updateScope.isDone()).toBe(true);
+        expect(deploymentScope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Build updated successfully.');
+    });
+    it('should convert rollout percentage to decimal', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            rolloutPercentage: 50,
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        const deploymentScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`, {
+            appId,
+            appBuildId: buildId,
+            appChannelName: 'production',
+            rolloutPercentage: 0.5,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(deploymentScope.isDone()).toBe(true);
+    });
+    it('should output JSON when json flag is set', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            json: true,
+            yes: true,
+        };
+        nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '42' });
+        nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify({
+            buildId,
+            buildNumberAsString: '42',
+            deploymentId,
+        }, null, 2));
+    });
+    it('should require app ID in non-interactive mode', async () => {
+        const options = { gitRef: 'main', channel: 'production' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide an app ID when running in non-interactive environment.');
+    });
+    it('should require git ref in non-interactive mode', async () => {
+        const options = { appId, channel: 'production' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide a git ref, path, or url when running in non-interactive environment.');
+    });
+    it('should require channel in non-interactive mode', async () => {
+        const options = { appId, gitRef: 'main' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide a channel when running in non-interactive environment.');
+    });
+    it('should handle build creation API error', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            yes: true,
+        };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Invalid build data' });
+        await expect(createCommand.action(options, undefined)).rejects.toThrow();
+        expect(buildScope.isDone()).toBe(true);
+    });
+    it('should include build URL in output', async () => {
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: 'production',
+            yes: true,
+        };
+        nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '1' });
+        nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId });
+        await createCommand.action(options, undefined);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${buildId}`);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Deployment URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/deployments/${deploymentId}`);
+    });
+});