@capawesome/cli 4.5.0 → 4.6.0-dev.12df3ca.1775037612

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

@@ -0,0 +1,300 @@
+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 create multiple deployments for multiple channels', async () => {
+        const deploymentId2 = '00000000-0000-0000-0000-000000000004';
+        const options = {
+            appId,
+            gitRef: 'main',
+            channel: ['production', 'staging'],
+            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 deploymentScope1 = 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 });
+        const deploymentScope2 = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/deployments`, {
+            appId,
+            appBuildId: buildId,
+            appChannelName: 'staging',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: deploymentId2 });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(deploymentScope1.isDone()).toBe(true);
+        expect(deploymentScope2.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Deployment created successfully.');
+        expect(mockConsola.info).toHaveBeenCalledWith(`Deployment ID: ${deploymentId}`);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Deployment ID: ${deploymentId2}`);
+    });
+    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',
+            deploymentIds: [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 at least one 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}`);
+    });
+});

package/dist/commands/apps/liveupdates/generate-manifest.js

@@ -1,5 +1,5 @@
 import { isInteractive } from '../../../utils/environment.js';
-import { fileExistsAtPath } 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 { defineCommand, defineOptions } from '@robingenz/zli';
@@ -32,6 +32,22 @@ export default defineCommand({
             consola.error(`The path does not exist.`);
             process.exit(1);
         }
+        // Check if the path is a directory
+        const pathIsDirectory = await isDirectory(path);
+        if (!pathIsDirectory) {
+            consola.error(`The path is not a directory.`);
+            process.exit(1);
+        }
+        // Check for source maps
+        const containsSourceMaps = await directoryContainsSourceMaps(path);
+        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.');
+        }
+        // Check for symlinks
+        const containsSymlinks = await directoryContainsSymlinks(path);
+        if (containsSymlinks) {
+            consola.warn('Symbolic links were detected in the specified path. Symbolic links are skipped during manifest generation.');
+        }
         // Generate the manifest file
         await generateManifestJson(path);
         consola.success('Manifest file generated.');

package/dist/commands/apps/liveupdates/generate-manifest.test.js

@@ -1,4 +1,4 @@
-import { fileExistsAtPath } from '../../../utils/file.js';
+import { directoryContainsSymlinks, fileExistsAtPath, isDirectory } from '../../../utils/file.js';
 import { generateManifestJson } from '../../../utils/manifest.js';
 import { prompt } from '../../../utils/prompt.js';
 import consola from 'consola';
@@ -14,6 +14,8 @@ vi.mock('@/utils/environment.js', () => ({
 }));
 describe('apps-liveupdates-generatemanifest', () => {
     const mockFileExistsAtPath = vi.mocked(fileExistsAtPath);
+    const mockIsDirectory = vi.mocked(isDirectory);
+    const mockDirectoryContainsSymlinks = vi.mocked(directoryContainsSymlinks);
     const mockGenerateManifestJson = vi.mocked(generateManifestJson);
     const mockPrompt = vi.mocked(prompt);
     const mockConsola = vi.mocked(consola);
@@ -29,6 +31,7 @@ describe('apps-liveupdates-generatemanifest', () => {
     it('should generate manifest with provided path', async () => {
         const options = { path: './dist' };
         mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
         mockGenerateManifestJson.mockResolvedValue(undefined);
         await generateManifestCommand.action(options, undefined);
         expect(mockFileExistsAtPath).toHaveBeenCalledWith('./dist');
@@ -39,6 +42,7 @@ describe('apps-liveupdates-generatemanifest', () => {
         const options = {};
         mockPrompt.mockResolvedValueOnce('./www');
         mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
         mockGenerateManifestJson.mockResolvedValue(undefined);
         await generateManifestCommand.action(options, undefined);
         expect(mockPrompt).toHaveBeenCalledWith('Enter the path to the web assets folder (e.g., `dist` or `www`):', {
@@ -60,4 +64,20 @@ describe('apps-liveupdates-generatemanifest', () => {
         await expect(generateManifestCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
         expect(mockConsola.error).toHaveBeenCalledWith('The path does not exist.');
     });
+    it('should handle non-directory path', async () => {
+        const options = { path: './file.txt' };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(false);
+        await expect(generateManifestCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The path is not a directory.');
+    });
+    it('should warn when symlinks are detected', async () => {
+        const options = { path: './dist' };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
+        mockDirectoryContainsSymlinks.mockResolvedValue(true);
+        mockGenerateManifestJson.mockResolvedValue(undefined);
+        await generateManifestCommand.action(options, undefined);
+        expect(mockConsola.warn).toHaveBeenCalledWith('Symbolic links were detected in the specified path. Symbolic links are skipped during manifest generation.');
+    });
 });

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

@@ -2,6 +2,7 @@ import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
 import appBundlesService from '../../../services/app-bundles.js';
 import appsService from '../../../services/apps.js';
 import { withAuth } from '../../../utils/auth.js';
+import { parseCustomProperties } from '../../../utils/custom-properties.js';
 import { createBufferFromPath, createBufferFromString, isPrivateKeyContent } from '../../../utils/buffer.js';
 import { isInteractive } from '../../../utils/environment.js';
 import { fileExistsAtPath } from '../../../utils/file.js';
@@ -14,7 +15,7 @@ import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Register a self-hosted bundle URL.',
+    description: 'Register a self-hosted bundle URL for serving artifacts from your own infrastructure.',
     options: defineOptions(z.object({
         androidMax: z.coerce
             .string()
@@ -52,6 +53,7 @@ export default defineCommand({
             .describe('The commit sha related to the bundle. Deprecated, use `--git-ref` instead.'),
         customProperty: z
             .array(z.string().min(1).max(100))
+            .max(10)
             .optional()
             .describe('A custom property to assign to the bundle. Must be in the format `key=value`. Can be specified multiple times.'),
         expiresInDays: z.coerce
@@ -192,7 +194,13 @@ export default defineCommand({
                     process.exit(1);
                 }
                 // Sign the bundle
-                signature = await createSignature(privateKeyBuffer, fileBuffer);
+                try {
+                    signature = await createSignature(privateKeyBuffer, fileBuffer);
+                }
+                catch {
+                    consola.error('Failed to parse the private key. Make sure the private key is a valid PEM-formatted key and is not encrypted.');
+                    process.exit(1);
+                }
             }
         }
         // Get app details for confirmation
@@ -237,16 +245,3 @@ export default defineCommand({
         consola.success('Live Update successfully registered.');
     }),
 });
-const parseCustomProperties = (customProperty) => {
-    let customProperties;
-    if (customProperty) {
-        customProperties = {};
-        for (const property of customProperty) {
-            const [key, value] = property.split('=');
-            if (key && value) {
-                customProperties[key] = value;
-            }
-        }
-    }
-    return customProperties;
-};

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

@@ -3,9 +3,10 @@ import appBundleFilesService from '../../../services/app-bundle-files.js';
 import appBundlesService from '../../../services/app-bundles.js';
 import appsService from '../../../services/apps.js';
 import { withAuth } from '../../../utils/auth.js';
+import { parseCustomProperties } from '../../../utils/custom-properties.js';
 import { createBufferFromPath, createBufferFromReadStream, createBufferFromString, isPrivateKeyContent, } from '../../../utils/buffer.js';
 import { isInteractive } from '../../../utils/environment.js';
-import { fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory } from '../../../utils/file.js';
+import { directoryContainsSourceMaps, directoryContainsSymlinks, fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory, } from '../../../utils/file.js';
 import { createHash } from '../../../utils/hash.js';
 import { generateManifestJson } from '../../../utils/manifest.js';
 import { formatPrivateKey } from '../../../utils/private-key.js';
@@ -18,7 +19,7 @@ import { createReadStream } from 'fs';
 import pathModule from 'path';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Upload a bundle to Capawesome Cloud.',
+    description: 'Upload a locally built bundle to Capawesome Cloud.',
     options: defineOptions(z.object({
         androidMax: z.coerce
             .string()
@@ -63,6 +64,7 @@ export default defineCommand({
             .describe('The commit sha related to the bundle. Deprecated, use `--git-ref` instead.'),
         customProperty: z
             .array(z.string().min(1).max(100))
+            .max(10)
             .optional()
             .describe('A custom property to assign to the bundle. Must be in the format `key=value`. Can be specified multiple times.'),
         expiresInDays: z.coerce
@@ -156,6 +158,20 @@ export default defineCommand({
             consola.error('The path must be either a folder or a zip file.');
             process.exit(1);
         }
+        // Check for symlinks
+        if (pathIsDirectory) {
+            const containsSymlinks = await directoryContainsSymlinks(path);
+            if (containsSymlinks) {
+                consola.warn('Symbolic links were detected in the specified path. Symbolic links are skipped during upload.');
+            }
+        }
+        // Check for source maps
+        if (pathIsDirectory) {
+            const containsSourceMaps = await directoryContainsSourceMaps(path);
+            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.');
+            }
+        }
         // Check that the path is a directory when creating a bundle with an artifact type of manifest
         if (artifactType === 'manifest') {
             const pathIsDirectory = await isDirectory(path);
@@ -283,7 +299,13 @@ const uploadFile = async (options) => {
         // Sign the bundle
         let signature;
         if (privateKeyBuffer) {
-            signature = await createSignature(privateKeyBuffer, buffer);
+            try {
+                signature = await createSignature(privateKeyBuffer, buffer);
+            }
+            catch {
+                consola.error('Failed to parse the private key. Make sure the private key is a valid PEM-formatted key and is not encrypted.');
+                process.exit(1);
+            }
         }
         // Create the multipart upload
         return await appBundleFilesService.create({
@@ -370,16 +392,3 @@ const uploadZip = async (options) => {
         appBundleFileId: result.id,
     };
 };
-const parseCustomProperties = (customProperty) => {
-    let customProperties;
-    if (customProperty) {
-        customProperties = {};
-        for (const property of customProperty) {
-            const [key, value] = property.split('=');
-            if (key && value) {
-                customProperties[key] = value;
-            }
-        }
-    }
-    return customProperties;
-};

package/dist/commands/manifests/generate.js

@@ -2,7 +2,7 @@ import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Generate a manifest file.',
+    description: 'Generate a manifest file. Deprecated, use `apps:liveupdates:generate-manifest` instead.',
     options: defineOptions(z.object({
         path: z.string().optional().describe('Path to the web assets folder (e.g. `www` or `dist`).'),
     })),

package/dist/index.js

@@ -52,6 +52,7 @@ const config = defineConfig({
         'apps:destinations:update': await import('./commands/apps/destinations/update.js').then((mod) => mod.default),
         'apps:devices:delete': await import('./commands/apps/devices/delete.js').then((mod) => mod.default),
         'apps:devices:forcechannel': await import('./commands/apps/devices/forcechannel.js').then((mod) => mod.default),
+        'apps:devices:probe': await import('./commands/apps/devices/probe.js').then((mod) => mod.default),
         'apps:devices:unforcechannel': await import('./commands/apps/devices/unforcechannel.js').then((mod) => mod.default),
         'apps:environments:create': await import('./commands/apps/environments/create.js').then((mod) => mod.default),
         'apps:environments:delete': await import('./commands/apps/environments/delete.js').then((mod) => mod.default),
@@ -59,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-build-sources.js

@@ -0,0 +1,120 @@
+import { MAX_CONCURRENT_PART_UPLOADS } from '../config/index.js';
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+import FormData from 'form-data';
+class AppBuildSourcesServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async createFromFile(dto, onProgress) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources`, { fileSizeInBytes: dto.fileSizeInBytes }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        await this.upload({
+            appBuildSourceId: response.data.id,
+            appId: dto.appId,
+            buffer: dto.buffer,
+            name: dto.name,
+        }, onProgress);
+        return response.data;
+    }
+    async createFromUrl(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources`, { fileUrl: dto.fileUrl }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async completeUpload(dto) {
+        return this.httpClient
+            .post(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-complete&uploadId=${dto.uploadId}`, {
+            parts: dto.parts,
+        }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        })
+            .then((response) => response.data);
+    }
+    async createUpload(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-create`, {}, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async createUploadPart(dto) {
+        const formData = new FormData();
+        formData.append('blob', dto.buffer, { filename: dto.name });
+        formData.append('partNumber', dto.partNumber.toString());
+        return this.httpClient
+            .put(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-uploadpart&uploadId=${dto.uploadId}`, formData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                ...formData.getHeaders(),
+            },
+        })
+            .then((response) => response.data);
+    }
+    async createUploadParts(dto, onProgress) {
+        const uploadedParts = [];
+        const partSize = 10 * 1024 * 1024; // 10 MB
+        const totalParts = Math.ceil(dto.buffer.byteLength / partSize);
+        let partNumber = 0;
+        const uploadNextPart = async () => {
+            if (partNumber >= totalParts) {
+                return;
+            }
+            partNumber++;
+            onProgress?.(partNumber, totalParts);
+            const start = (partNumber - 1) * partSize;
+            const end = Math.min(start + partSize, dto.buffer.byteLength);
+            const partBuffer = dto.buffer.subarray(start, end);
+            const uploadedPart = await this.createUploadPart({
+                appBuildSourceId: dto.appBuildSourceId,
+                appId: dto.appId,
+                buffer: partBuffer,
+                name: dto.name,
+                partNumber,
+                uploadId: dto.uploadId,
+            });
+            uploadedParts.push(uploadedPart);
+            await uploadNextPart();
+        };
+        const uploadPartPromises = Array.from({ length: MAX_CONCURRENT_PART_UPLOADS });
+        for (let i = 0; i < MAX_CONCURRENT_PART_UPLOADS; i++) {
+            uploadPartPromises[i] = uploadNextPart();
+        }
+        await Promise.all(uploadPartPromises);
+        return uploadedParts.sort((a, b) => a.partNumber - b.partNumber);
+    }
+    async upload(dto, onProgress) {
+        // 1. Create a multipart upload
+        const { uploadId } = await this.createUpload({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+        });
+        // 2. Upload the file in parts
+        const parts = await this.createUploadParts({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+            buffer: dto.buffer,
+            name: dto.name,
+            uploadId,
+        }, onProgress);
+        // 3. Complete the upload
+        await this.completeUpload({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+            parts,
+            uploadId,
+        });
+    }
+}
+const appBuildSourcesService = new AppBuildSourcesServiceImpl(httpClient);
+export default appBuildSourcesService;