@capawesome/cli 3.10.2 → 4.0.0

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

@@ -0,0 +1,325 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory } from '../../../utils/file.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 uploadCommand from './upload.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('@/utils/file.js');
+vi.mock('@/utils/zip.js');
+vi.mock('@/utils/buffer.js');
+vi.mock('@/utils/private-key.js');
+vi.mock('@/utils/hash.js');
+vi.mock('@/utils/signature.js');
+vi.mock('@/utils/manifest.js');
+vi.mock('@/utils/environment.js');
+vi.mock('consola');
+describe('apps-liveupdates-upload', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockFileExistsAtPath = vi.mocked(fileExistsAtPath);
+    const mockGetFilesInDirectoryAndSubdirectories = vi.mocked(getFilesInDirectoryAndSubdirectories);
+    const mockIsDirectory = vi.mocked(isDirectory);
+    const mockIsInteractive = vi.mocked(isInteractive);
+    const mockConsola = vi.mocked(consola);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockIsInteractive.mockReturnValue(false);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should require authentication', async () => {
+        const appId = 'app-123';
+        const options = { appId, path: './dist', artifactType: 'zip', rollout: 1 };
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(false);
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must be logged in to run this command. Please run the `login` command first.');
+    });
+    it('should handle path validation errors', async () => {
+        const appId = 'app-123';
+        const nonexistentPath = './nonexistent';
+        const options = { appId, path: nonexistentPath, artifactType: 'zip', rollout: 1 };
+        mockFileExistsAtPath.mockResolvedValue(false);
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The path does not exist.');
+    });
+    it('should validate manifest artifact type requires directory', async () => {
+        const appId = 'app-123';
+        const bundlePath = './bundle.zip';
+        const options = {
+            appId,
+            path: bundlePath,
+            artifactType: 'manifest',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(false);
+        // Mock zip utility to return true so path validation passes
+        const mockZip = await import('../../../utils/zip.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The path must be a folder when creating a bundle with an artifact type of `manifest`.');
+    });
+    it('should upload bundle successfully', async () => {
+        const appId = 'app-123';
+        const bundlePath = './dist';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const options = {
+            appId,
+            path: bundlePath,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
+        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
+            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
+        ]);
+        // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
+        const mockBuffer = await import('../../../utils/buffer.js');
+        const mockHash = await import('../../../utils/hash.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(false);
+        vi.mocked(mockZip.default.zipFolder).mockResolvedValue(testBuffer);
+        vi.mocked(mockHash.createHash).mockResolvedValue('test-hash');
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            artifactType: 'zip',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        const uploadScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles/${bundleId}/files`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: 'file-123' });
+        const updateScope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: bundleId });
+        await uploadCommand.action(options, undefined);
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
+        expect(uploadScope.isDone()).toBe(true);
+        expect(updateScope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Build Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully uploaded.');
+    });
+    it('should pass gitRef to API when provided', async () => {
+        const appId = 'app-123';
+        const bundlePath = './dist';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const gitRef = 'main';
+        const options = {
+            appId,
+            path: bundlePath,
+            artifactType: 'zip',
+            rollout: 1,
+            gitRef,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
+        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
+            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
+        ]);
+        // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
+        const mockHash = await import('../../../utils/hash.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(false);
+        vi.mocked(mockZip.default.zipFolder).mockResolvedValue(testBuffer);
+        vi.mocked(mockHash.createHash).mockResolvedValue('test-hash');
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            artifactType: 'zip',
+            gitRef,
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        const uploadScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles/${bundleId}/files`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: 'file-123' });
+        const updateScope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: bundleId });
+        await uploadCommand.action(options, undefined);
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
+        expect(uploadScope.isDone()).toBe(true);
+        expect(updateScope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Build Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully uploaded.');
+    });
+    it('should handle private key file path', async () => {
+        const appId = 'app-123';
+        const bundlePath = './dist';
+        const privateKeyPath = 'private-key.pem';
+        const testHash = 'test-hash';
+        const testSignature = 'test-signature';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const options = {
+            appId,
+            path: bundlePath,
+            privateKey: privateKeyPath,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockImplementation((path) => {
+            if (path === privateKeyPath)
+                return Promise.resolve(true);
+            if (path === bundlePath)
+                return Promise.resolve(true);
+            return Promise.resolve(false);
+        });
+        mockIsDirectory.mockResolvedValue(true);
+        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
+            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
+        ]);
+        // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
+        const mockBuffer = await import('../../../utils/buffer.js');
+        const mockPrivateKey = await import('../../../utils/private-key.js');
+        const mockHash = await import('../../../utils/hash.js');
+        const mockSignature = await import('../../../utils/signature.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(false);
+        vi.mocked(mockZip.default.zipFolder).mockResolvedValue(testBuffer);
+        vi.mocked(mockBuffer.createBufferFromPath).mockResolvedValue(testBuffer);
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
+        vi.mocked(mockPrivateKey.formatPrivateKey).mockReturnValue('formatted-private-key');
+        vi.mocked(mockBuffer.createBufferFromString).mockReturnValue(testBuffer);
+        vi.mocked(mockHash.createHash).mockResolvedValue(testHash);
+        vi.mocked(mockSignature.createSignature).mockResolvedValue(testSignature);
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId, appBuildId: 'build-789' });
+        const uploadScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles/${bundleId}/files`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: 'file-123' });
+        const updateScope = nock(DEFAULT_API_BASE_URL)
+            .patch(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: bundleId });
+        await uploadCommand.action(options, undefined);
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
+        expect(uploadScope.isDone()).toBe(true);
+        expect(updateScope.isDone()).toBe(true);
+        expect(mockConsola.info).toHaveBeenCalledWith(`Build Artifact ID: ${bundleId}`);
+        expect(mockConsola.success).toHaveBeenCalledWith('Live Update successfully uploaded.');
+    });
+    it('should handle private key file not found', async () => {
+        const appId = 'app-123';
+        const privateKeyPath = 'nonexistent-key.pem';
+        const options = {
+            appId,
+            path: './dist',
+            privateKey: privateKeyPath,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockImplementation((path) => {
+            if (path === privateKeyPath)
+                return Promise.resolve(false);
+            return Promise.resolve(true);
+        });
+        mockIsDirectory.mockResolvedValue(true);
+        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
+            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
+        ]);
+        // Mock utility functions
+        const mockBuffer = await import('../../../utils/buffer.js');
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('Private key file not found.');
+    });
+    it('should handle invalid private key format', async () => {
+        const appId = 'app-123';
+        const invalidPrivateKey = 'not-a-valid-key';
+        const options = {
+            appId,
+            path: './dist',
+            privateKey: invalidPrivateKey,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(false);
+        // Mock zip utility to pass path validation
+        const mockZip = await import('../../../utils/zip.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(true);
+        // Mock utility functions
+        const mockBuffer = await import('../../../utils/buffer.js');
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('Private key must be either a path to a .pem file or the private key content as plain text.');
+    });
+    it('should handle API error during creation', async () => {
+        const appId = 'app-123';
+        const bundlePath = './dist';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const options = {
+            appId,
+            path: bundlePath,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(true);
+        mockGetFilesInDirectoryAndSubdirectories.mockResolvedValue([
+            { href: 'index.html', mimeType: 'text/html', name: 'index.html', path: 'index.html' },
+        ]);
+        // Mock utility functions
+        const mockZip = await import('../../../utils/zip.js');
+        vi.mocked(mockZip.default.isZipped).mockReturnValue(false);
+        vi.mocked(mockZip.default.zipFolder).mockResolvedValue(testBuffer);
+        const appScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        const bundleScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Invalid bundle data' });
+        await expect(uploadCommand.action(options, undefined)).rejects.toThrow();
+        expect(appScope.isDone()).toBe(true);
+        expect(bundleScope.isDone()).toBe(true);
+    });
+});

package/dist/commands/manifests/generate.js

@@ -1,9 +1,5 @@
-import { fileExistsAtPath } from '../../utils/file.js';
-import { generateManifestJson } from '../../utils/manifest.js';
-import { prompt } from '../../utils/prompt.js';
 import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
-import { isInteractive } from '../../utils/environment.js';
 import { z } from 'zod';
 export default defineCommand({
     description: 'Generate a manifest file.',
@@ -11,28 +7,7 @@ export default defineCommand({
         path: z.string().optional().describe('Path to the web assets folder (e.g. `www` or `dist`).'),
     })),
     action: async (options, args) => {
-        let path = options.path;
-        if (!path) {
-            if (!isInteractive()) {
-                consola.error('You must provide the path to the web assets folder when running in non-interactive environment.');
-                process.exit(1);
-            }
-            path = await prompt('Enter the path to the web assets folder:', {
-                type: 'text',
-            });
-            if (!path) {
-                consola.error('You must provide a path to the web assets folder.');
-                process.exit(1);
-            }
-        }
-        // Check if the path exists
-        const pathExists = await fileExistsAtPath(path);
-        if (!pathExists) {
-            consola.error(`The path does not exist.`);
-            process.exit(1);
-        }
-        // Generate the manifest file
-        await generateManifestJson(path);
-        consola.success('Manifest file generated.');
+        consola.warn('The `manifests:generate` command has been deprecated. Please use `apps:liveupdates:generatemanifest` instead.');
+        process.exit(0);
     },
 });

package/dist/commands/organizations/create.js

@@ -24,7 +24,7 @@ export default defineCommand({
             name = await prompt('Enter the name of the organization:', { type: 'text' });
         }
         const response = await organizationsService.create({ name });
-        consola.success('Organization created successfully.');
         consola.info(`Organization ID: ${response.id}`);
+        consola.success('Organization created successfully.');
     },
 });

package/dist/index.js

@@ -34,12 +34,25 @@ const config = defineConfig({
         'apps:channels:delete': await import('./commands/apps/channels/delete.js').then((mod) => mod.default),
         'apps:channels:get': await import('./commands/apps/channels/get.js').then((mod) => mod.default),
         'apps:channels:list': await import('./commands/apps/channels/list.js').then((mod) => mod.default),
+        'apps:channels:pause': await import('./commands/apps/channels/pause.js').then((mod) => mod.default),
+        'apps:channels:resume': await import('./commands/apps/channels/resume.js').then((mod) => mod.default),
         'apps:channels:update': await import('./commands/apps/channels/update.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),
+        'apps:environments:list': await import('./commands/apps/environments/list.js').then((mod) => mod.default),
+        '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:deployments:create': await import('./commands/apps/deployments/create.js').then((mod) => mod.default),
         'apps:deployments:cancel': await import('./commands/apps/deployments/cancel.js').then((mod) => mod.default),
         'apps:deployments:logs': await import('./commands/apps/deployments/logs.js').then((mod) => mod.default),
         'apps:devices:delete': await import('./commands/apps/devices/delete.js').then((mod) => mod.default),
+        'apps:liveupdates:bundle': await import('./commands/apps/liveupdates/bundle.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),
+        'apps:liveupdates:upload': await import('./commands/apps/liveupdates/upload.js').then((mod) => mod.default),
+        'apps:liveupdates:register': await import('./commands/apps/liveupdates/register.js').then((mod) => mod.default),
+        'apps:liveupdates:generatemanifest': await import('./commands/apps/liveupdates/generate-manifest.js').then((mod) => mod.default),
         'manifests:generate': await import('./commands/manifests/generate.js').then((mod) => mod.default),
         'organizations:create': await import('./commands/organizations/create.js').then((mod) => mod.default),
     },

package/dist/services/app-builds.js

@@ -15,11 +15,18 @@ class AppBuildsServiceImpl {
         return response.data;
     }
     async findAll(dto) {
-        const { appId } = dto;
-        const response = await this.httpClient.get(`/v1/apps/${appId}/builds`, {
+        const params = {};
+        if (dto.platform) {
+            params.platform = dto.platform;
+        }
+        if (dto.numberAsString) {
+            params.numberAsString = dto.numberAsString;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/builds`, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
+            params,
         });
         return response.data;
     }

package/dist/services/app-channels.js

@@ -51,13 +51,32 @@ class AppChannelsServiceImpl {
         return response.data;
     }
     async findOneById(data) {
+        const params = {};
+        if (data.relations) {
+            params.relations = data.relations;
+        }
         const response = await this.httpClient.get(`/v1/apps/${data.appId}/channels/${data.id}`, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
+            params,
         });
         return response.data;
     }
+    async pause(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/channels/${dto.channelId}/pause`, {}, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async resume(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/channels/${dto.channelId}/resume`, {}, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
     async update(dto) {
         const response = await this.httpClient.patch(`/v1/apps/${dto.appId}/channels/${dto.appChannelId}`, dto, {
             headers: {

package/dist/services/app-deployments.js

@@ -6,14 +6,7 @@ class AppDeploymentsServiceImpl {
         this.httpClient = httpClient;
     }
     async create(dto) {
-        const { appId, appBuildId, appDestinationName } = dto;
-        const bodyData = {
-            appBuildId,
-        };
-        if (appDestinationName) {
-            bodyData.appDestinationName = appDestinationName;
-        }
-        const response = await this.httpClient.post(`/v1/apps/${appId}/deployments`, bodyData, {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/deployments`, dto, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
@@ -21,21 +14,30 @@ class AppDeploymentsServiceImpl {
         return response.data;
     }
     async findAll(dto) {
-        const { appId } = dto;
-        const response = await this.httpClient.get(`/v1/apps/${appId}/deployments`, {
+        const params = {};
+        if (dto.appChannelId) {
+            params.appChannelId = dto.appChannelId;
+        }
+        if (dto.limit) {
+            params.limit = dto.limit.toString();
+        }
+        if (dto.relations) {
+            params.relations = dto.relations;
+        }
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/deployments`, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
+            params,
         });
         return response.data;
     }
     async findOne(dto) {
-        const { appId, appDeploymentId, relations } = dto;
         const params = {};
-        if (relations) {
-            params.relations = relations;
+        if (dto.relations) {
+            params.relations = dto.relations;
         }
-        const response = await this.httpClient.get(`/v1/apps/${appId}/deployments/${appDeploymentId}`, {
+        const response = await this.httpClient.get(`/v1/apps/${dto.appId}/deployments/${dto.appDeploymentId}`, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
@@ -43,6 +45,14 @@ class AppDeploymentsServiceImpl {
         });
         return response.data;
     }
+    async update(dto) {
+        const response = await this.httpClient.patch(`/v1/apps/${dto.appId}/deployments/${dto.appDeploymentId}`, dto, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
 }
 const appDeploymentsService = new AppDeploymentsServiceImpl(httpClient);
 export default appDeploymentsService;

package/dist/services/app-environments.js

@@ -5,15 +5,80 @@ class AppEnvironmentsServiceImpl {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
+    async create(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/environments`, dto, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async delete(dto) {
+        if (dto.id) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/environments/${dto.id}`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+            });
+        }
+        else if (dto.name) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/environments`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+                params: {
+                    name: dto.name,
+                },
+            });
+        }
+    }
     async findAll(dto) {
-        const { appId } = dto;
-        const response = await this.httpClient.get(`/v1/apps/${appId}/environments`, {
+        const queryParams = new URLSearchParams();
+        if (dto.limit) {
+            queryParams.append('limit', dto.limit.toString());
+        }
+        if (dto.offset) {
+            queryParams.append('offset', dto.offset.toString());
+        }
+        const queryString = queryParams.toString();
+        const url = queryString
+            ? `/v1/apps/${dto.appId}/environments?${queryString}`
+            : `/v1/apps/${dto.appId}/environments`;
+        const response = await this.httpClient.get(url, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
         });
         return response.data;
     }
+    async setVariables(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/variables/set`, dto.variables, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async setSecrets(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/secrets/set`, dto.secrets, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async unsetVariables(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/variables/unset`, dto.keys, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async unsetSecrets(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/secrets/unset`, dto.keys, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
 }
 const appEnvironmentsService = new AppEnvironmentsServiceImpl(httpClient);
 export default appEnvironmentsService;

package/dist/services/config.js

@@ -9,6 +9,7 @@ class ConfigServiceImpl {
         return (await this.config)[key];
     }
     async loadConfig() {
+        const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
         const { config } = await loadConfig({
             defaults: {
                 API_BASE_URL: DEFAULT_API_BASE_URL,
@@ -16,6 +17,7 @@ class ConfigServiceImpl {
                 ENVIRONMENT: 'production',
             },
             name: 'capawesome',
+            rcFile: isTestEnvironment ? false : undefined,
         });
         return config;
     }

package/dist/utils/app-environments.js

@@ -0,0 +1,35 @@
+/**
+ * Parse key-value pairs from content string.
+ *
+ * Format: KEY=value (one per line)
+ * - Empty lines are ignored
+ * - Lines starting with # are ignored (comments)
+ * - Lines without = are skipped
+ * - Keys and values are trimmed
+ * - Values can contain = characters
+ * - Lines with empty keys are skipped
+ * - Lines with empty values are skipped
+ *
+ * @param content - Content string to parse
+ * @returns Array of key-value pairs
+ */
+export function parseKeyValuePairs(content) {
+    const lines = content.split('\n');
+    const pairs = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const separatorIndex = trimmed.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, separatorIndex).trim();
+        const value = trimmed.slice(separatorIndex + 1).trim();
+        if (key && value) {
+            pairs.push({ key, value });
+        }
+    }
+    return pairs;
+}