@capawesome/cli 4.6.0 → 4.8.0-dev.efa0850.1775645973

package/dist/commands/apps/create.js

@@ -1,3 +1,4 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../config/consts.js';
 import appsService from '../../services/apps.js';
 import { withAuth } from '../../utils/auth.js';
 import { isInteractive } from '../../utils/environment.js';
@@ -8,11 +9,14 @@ import { z } from 'zod';
 export default defineCommand({
     description: 'Create a new app.',
     options: defineOptions(z.object({
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        link: z.boolean().optional().describe('Connect the created app to the local git repository.'),
         name: z.string().optional().describe('Name of the app.'),
         organizationId: z.string().optional().describe('ID of the organization to create the app in.'),
-    })),
+        yes: z.boolean().optional().describe('Skip all confirmation prompts.'),
+    }), { y: 'yes' }),
     action: withAuth(async (options, args) => {
-        let { name, organizationId } = options;
+        let { json, name, organizationId } = options;
         if (!organizationId) {
             if (!isInteractive()) {
                 consola.error('You must provide the organization ID when running in non-interactive environment.');
@@ -28,7 +32,22 @@ export default defineCommand({
             name = await prompt('Enter the name of the app:', { type: 'text' });
         }
         const response = await appsService.create({ name, organizationId });
-        consola.info(`App ID: ${response.id}`);
-        consola.success('App created successfully.');
+        if (!json) {
+            consola.info(`App ID: ${response.id}`);
+            consola.info(`App URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${response.id}`);
+            consola.success('App created successfully.');
+        }
+        let shouldLink = options.link ?? false;
+        if (!shouldLink && !options.yes && !json && isInteractive()) {
+            shouldLink = await prompt('Do you want to connect a git repository?', {
+                type: 'confirm',
+            });
+        }
+        if (shouldLink) {
+            await (await import('../../commands/apps/link.js').then((mod) => mod.default)).action({ appId: response.id }, undefined);
+        }
+        if (json) {
+            console.log(JSON.stringify({ id: response.id }, null, 2));
+        }
     }),
 });

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';