@capawesome/cli 4.6.0-dev.a84b1ba.1774341927 → 4.6.0-dev.bda9e9d.1774345600

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

@@ -2,11 +2,10 @@ 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 { unescapeAnsi } from '../../../utils/ansi.js';
+import { waitForBuildCompletion } from '../../../utils/build.js';
 import { withAuth } from '../../../utils/auth.js';
 import { isInteractive } from '../../../utils/environment.js';
 import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
-import { wait } from '../../../utils/wait.js';
 import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import fs from 'fs/promises';
@@ -215,127 +214,59 @@ export default defineCommand({
         // 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.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 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,
-                                });
-                            }
-                            if (options.zip && platform === 'web') {
-                                await handleArtifactDownload({
-                                    appId,
-                                    buildId: response.id,
-                                    buildArtifacts: build.appBuildArtifacts,
-                                    artifactType: 'zip',
-                                    filePath: typeof options.zip === 'string' ? options.zip : undefined,
-                                });
-                            }
-                            // Output JSON if json flag is set
-                            if (json) {
-                                console.log(JSON.stringify({
-                                    id: response.id,
-                                    numberAsString: response.numberAsString,
-                                }, null, 2));
-                            }
-                            break;
-                        }
-                        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);
-                }
+            const build = await waitForBuildCompletion({
+                appId,
+                appBuildId: response.id,
+                relations: 'appBuildArtifacts,job,job.jobLogs',
+            });
+            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 completed successfully.');
+            console.log();
+            // 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,
+                });
+            }
+            if (options.zip && platform === 'web') {
+                await handleArtifactDownload({
+                    appId,
+                    buildId: response.id,
+                    buildArtifacts: build.appBuildArtifacts,
+                    artifactType: 'zip',
+                    filePath: typeof options.zip === 'string' ? options.zip : undefined,
+                });
+            }
+            // Output JSON if json flag is set
+            if (json) {
+                console.log(JSON.stringify({
+                    id: response.id,
+                    numberAsString: response.numberAsString,
+                }, null, 2));
             }
         }
         else {

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

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

@@ -0,0 +1,189 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appBuildsService from '../../../services/app-builds.js';
+import appDeploymentsService from '../../../services/app-deployments.js';
+import appCertificatesService from '../../../services/app-certificates.js';
+import appEnvironmentsService from '../../../services/app-environments.js';
+import { withAuth } from '../../../utils/auth.js';
+import { waitForBuildCompletion } from '../../../utils/build.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new live update.',
+    options: defineOptions(z.object({
+        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.'),
+        gitRef: z.string().optional().describe('The Git reference (branch, tag, or commit SHA) to build.'),
+        environment: z.string().optional().describe('The name of the environment to use for the build.'),
+        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.'),
+        androidMin: z.string().optional().describe('The minimum Android versionCode for the live update.'),
+        androidMax: z.string().optional().describe('The maximum Android versionCode for the live update.'),
+        androidEq: z.string().optional().describe('The exact Android versionCode for the live update.'),
+        iosMin: z.string().optional().describe('The minimum iOS CFBundleVersion for the live update.'),
+        iosMax: z.string().optional().describe('The maximum iOS CFBundleVersion for the live update.'),
+        iosEq: z.string().optional().describe('The exact iOS CFBundleVersion for the live update.'),
+        rolloutPercentage: z
+            .number()
+            .int()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe('The rollout percentage for the deployment (0-100). Default: 100.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompts.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options) => {
+        let { appId, certificate, channel, gitRef, environment, json, stack } = options;
+        // 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
+        if (!gitRef) {
+            if (!isInteractive()) {
+                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);
+            }
+        }
+        // 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 })),
+                    });
+                }
+            }
+        }
+        // Create the web build
+        consola.start('Creating build...');
+        const response = await appBuildsService.create({
+            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 waitForBuildCompletion({ appId, appBuildId: response.id });
+        consola.success('Build completed successfully.');
+        console.log();
+        // Update build with version constraints if any are provided
+        const hasVersionConstraints = options.androidMin ||
+            options.androidMax ||
+            options.androidEq ||
+            options.iosMin ||
+            options.iosMax ||
+            options.iosEq;
+        if (hasVersionConstraints) {
+            consola.start('Updating version constraints...');
+            await appBuildsService.update({
+                appId,
+                appBuildId: response.id,
+                minAndroidAppVersionCode: options.androidMin,
+                maxAndroidAppVersionCode: options.androidMax,
+                eqAndroidAppVersionCode: options.androidEq,
+                minIosAppVersionCode: options.iosMin,
+                maxIosAppVersionCode: options.iosMax,
+                eqIosAppVersionCode: options.iosEq,
+            });
+            consola.success('Version constraints 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/index.js

@@ -60,6 +60,7 @@ const config = defineConfig({
         'apps:environments:set': await import('./commands/apps/environments/set.js').then((mod) => mod.default),
         'apps:environments:unset': await import('./commands/apps/environments/unset.js').then((mod) => mod.default),
         'apps:liveupdates:bundle': await import('./commands/apps/liveupdates/bundle.js').then((mod) => mod.default),
+        'apps:liveupdates:create': await import('./commands/apps/liveupdates/create.js').then((mod) => mod.default),
         'apps:liveupdates:generatesigningkey': await import('./commands/apps/liveupdates/generate-signing-key.js').then((mod) => mod.default),
         'apps:liveupdates:rollback': await import('./commands/apps/liveupdates/rollback.js').then((mod) => mod.default),
         'apps:liveupdates:rollout': await import('./commands/apps/liveupdates/rollout.js').then((mod) => mod.default),

package/dist/services/app-devices.js

@@ -55,14 +55,6 @@ class AppDevicesServiceImpl {
             },
         });
     }
-    async updateMany(data) {
-        const ids = data.deviceIds.join(',');
-        await this.httpClient.patch(`/v1/apps/${data.appId}/devices?ids=${ids}`, { forcedAppChannelId: data.forcedAppChannelId }, {
-            headers: {
-                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
-            },
-        });
-    }
 }
 const appDevicesService = new AppDevicesServiceImpl(httpClient);
 export default appDevicesService;

package/dist/utils/build.js

@@ -0,0 +1,74 @@
+import appBuildsService from '../services/app-builds.js';
+import { unescapeAnsi } from '../utils/ansi.js';
+import { wait } from '../utils/wait.js';
+import consola from 'consola';
+export const waitForBuildCompletion = async (options) => {
+    const { appId, appBuildId, relations = 'job,job.jobLogs' } = options;
+    let lastPrintedLogNumber = 0;
+    let isWaitingForStart = true;
+    while (true) {
+        try {
+            const build = await appBuildsService.findOne({
+                appId,
+                appBuildId,
+                relations,
+            });
+            if (!build.job) {
+                await wait(3000);
+                continue;
+            }
+            const jobStatus = build.job.status;
+            if (jobStatus === 'queued' || jobStatus === 'pending') {
+                if (isWaitingForStart) {
+                    consola.start(`Waiting for build to start (status: ${jobStatus})...`);
+                }
+                await wait(3000);
+                continue;
+            }
+            if (isWaitingForStart && jobStatus === 'in_progress') {
+                isWaitingForStart = false;
+                consola.success('Build started...');
+            }
+            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;
+                }
+            }
+            if (jobStatus === 'succeeded' ||
+                jobStatus === 'failed' ||
+                jobStatus === 'canceled' ||
+                jobStatus === 'rejected' ||
+                jobStatus === 'timed_out') {
+                console.log();
+                if (jobStatus === 'succeeded') {
+                    return build;
+                }
+                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);
+                }
+            }
+            await wait(3000);
+        }
+        catch (error) {
+            consola.error('Error polling build status:', error);
+            process.exit(1);
+        }
+    }
+};

package/package.json

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