@capawesome/cli 1.14.0-dev.8c382fa.1755584275 → 2.0.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [2.0.0](https://github.com/capawesome-team/cli/compare/v1.14.0...v2.0.0) (2025-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* You should now call the CLI using `@capawesome/cli` instead of just `capawesome`.
+* set npm minimum version to `8.0.0`
+* set Node.js minimum version to `16.0.0`
+
+* deprecate `capawesome` command ([d59ea30](https://github.com/capawesome-team/cli/commit/d59ea305b7bb873071162b2ef896fc2f87b7ea21))
+* set Node.js minimum version to `16.0.0` ([396688c](https://github.com/capawesome-team/cli/commit/396688c96b69131dc0433e79af2d79eca19ee7fe))
+* set npm minimum version to `8.0.0` ([8c382fa](https://github.com/capawesome-team/cli/commit/8c382fab37c53b0df8d7efc18e6a0efbb45e1c39))
+
+
+### Features
+
+* add `organizations:create` command ([a3b5855](https://github.com/capawesome-team/cli/commit/a3b5855a84f0c58cc0463b40c9965811837d92bb))
+* add link to report bugs ([#64](https://github.com/capawesome-team/cli/issues/64)) ([9eb95b2](https://github.com/capawesome-team/cli/commit/9eb95b2d1e8b47cb0f13f26aae6cccb50ec401e0)), closes [#56](https://github.com/capawesome-team/cli/issues/56)
+* **apps:bundles:create:** support private key as plain text or file path ([#62](https://github.com/capawesome-team/cli/issues/62)) ([1db77a2](https://github.com/capawesome-team/cli/commit/1db77a2aa665f8f28e459598112a37e22c391944)), closes [#25](https://github.com/capawesome-team/cli/issues/25)
+
+
+### Bug Fixes
+
+* add missing authorization token checks to commands ([6699b1e](https://github.com/capawesome-team/cli/commit/6699b1e6993cc8f4ff5cdcd5ebef64de53a93b0e))
+* handle private keys without line breaks ([#66](https://github.com/capawesome-team/cli/issues/66)) ([d1b8d2f](https://github.com/capawesome-team/cli/commit/d1b8d2f69e64b9c97d0117a305e9bca0ec158d4f)), closes [#30](https://github.com/capawesome-team/cli/issues/30)
+* **utils:** add error message for 403 status ([6922448](https://github.com/capawesome-team/cli/commit/69224483114190ff0b81e0dcfeb656e7ea208f54))
+
 ## [1.14.0](https://github.com/capawesome-team/cli/compare/v1.13.2...v1.14.0) (2025-08-11)
 
 

package/README.md

@@ -1,5 +1,9 @@
 # cli
 
+[![npm version](https://img.shields.io/npm/v/@capawesome/cli)](https://www.npmjs.com/package/@capawesome/cli)
+[![npm downloads](https://img.shields.io/npm/dm/@capawesome/cli)](https://www.npmjs.com/package/@capawesome/cli)
+[![license](https://img.shields.io/npm/l/@capawesome/cli)](https://github.com/capawesome-team/cli/blob/main/LICENSE)
+
 💻 The Capawesome Cloud Command Line Interface (CLI) can be used to manage [Live Updates](https://capawesome.io/cloud/) from the command line.
 
 ## Installation

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

@@ -1,21 +1,21 @@
-import { defineCommand, defineOptions } from '@robingenz/zli';
-import consola from 'consola';
-import { createReadStream } from 'fs';
-import { z } from 'zod';
 import { MAX_CONCURRENT_UPLOADS } from '../../../config/index.js';
 import appBundleFilesService from '../../../services/app-bundle-files.js';
 import appBundlesService from '../../../services/app-bundles.js';
 import appsService from '../../../services/apps.js';
 import authorizationService from '../../../services/authorization-service.js';
 import organizationsService from '../../../services/organizations.js';
-import { createBufferFromPath, createBufferFromReadStream } from '../../../utils/buffer.js';
-import { getMessageFromUnknownError } from '../../../utils/error.js';
+import { createBufferFromPath, createBufferFromReadStream, createBufferFromString, isPrivateKeyContent, } from '../../../utils/buffer.js';
+import { formatPrivateKey } from '../../../utils/private-key.js';
 import { fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory } from '../../../utils/file.js';
 import { createHash } from '../../../utils/hash.js';
 import { generateManifestJson } from '../../../utils/manifest.js';
 import { prompt } from '../../../utils/prompt.js';
 import { createSignature } from '../../../utils/signature.js';
 import zip from '../../../utils/zip.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { createReadStream } from 'fs';
+import { z } from 'zod';
 export default defineCommand({
     description: 'Create a new app bundle.',
     options: defineOptions(z.object({
@@ -72,7 +72,10 @@ export default defineCommand({
             .string()
             .optional()
             .describe('Path to the bundle to upload. Must be a folder (e.g. `www` or `dist`) or a zip file.'),
-        privateKey: z.string().optional().describe('The path to the private key file to sign the bundle with.'),
+        privateKey: z
+            .string()
+            .optional()
+            .describe('The private key to sign the bundle with. Can be a file path to a .pem file or the private key content as plain text.'),
         rollout: z.coerce
             .number()
             .min(0)
@@ -189,10 +192,19 @@ export default defineCommand({
         // Create the private key buffer
         let privateKeyBuffer;
         if (privateKey) {
-            if (privateKey.endsWith('.pem')) {
+            if (isPrivateKeyContent(privateKey)) {
+                // Handle plain text private key content
+                const formattedPrivateKey = formatPrivateKey(privateKey);
+                privateKeyBuffer = createBufferFromString(formattedPrivateKey);
+            }
+            else if (privateKey.endsWith('.pem')) {
+                // Handle file path
                 const fileExists = await fileExistsAtPath(privateKey);
                 if (fileExists) {
-                    privateKeyBuffer = await createBufferFromPath(privateKey);
+                    const keyBuffer = await createBufferFromPath(privateKey);
+                    const keyContent = keyBuffer.toString('utf8');
+                    const formattedPrivateKey = formatPrivateKey(keyContent);
+                    privateKeyBuffer = createBufferFromString(formattedPrivateKey);
                 }
                 else {
                     consola.error('Private key file not found.');
@@ -200,7 +212,7 @@ export default defineCommand({
                 }
             }
             else {
-                consola.error('Private key must be a path to a .pem file.');
+                consola.error('Private key must be either a path to a .pem file or the private key content as plain text.');
                 process.exit(1);
             }
         }
@@ -277,9 +289,7 @@ export default defineCommand({
                     // No-op
                 });
             }
-            const message = getMessageFromUnknownError(error);
-            consola.error(message);
-            process.exit(1);
+            throw error;
         }
     },
 });

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

@@ -0,0 +1,276 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { fileExistsAtPath, 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 createBundleCommand from './create.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('consola');
+describe('apps-bundles-create', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockFileExistsAtPath = vi.mocked(fileExistsAtPath);
+    const mockIsDirectory = vi.mocked(isDirectory);
+    const mockConsola = vi.mocked(consola);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        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(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must be logged in to run this command.');
+    });
+    it('should create bundle with self-hosted URL', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './bundle.zip';
+        const testHash = 'test-hash';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const options = {
+            appId,
+            url: bundleUrl,
+            path: bundlePath,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(false);
+        // 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(true);
+        vi.mocked(mockBuffer.createBufferFromPath).mockResolvedValue(testBuffer);
+        vi.mocked(mockHash.createHash).mockResolvedValue(testHash);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            url: bundleUrl,
+            checksum: testHash,
+            artifactType: 'zip',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId });
+        await createBundleCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
+        expect(mockConsola.info).toHaveBeenCalledWith(`Bundle ID: ${bundleId}`);
+    });
+    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(createBundleCommand.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);
+        await expect(createBundleCommand.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 validate manifest artifact type cannot use URL', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const options = {
+            appId,
+            url: bundleUrl,
+            artifactType: 'manifest',
+            rollout: 1,
+        };
+        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('It is not yet possible to provide a URL when creating a bundle with an artifact type of `manifest`.');
+    });
+    it('should handle API error during creation', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const testToken = 'test-token';
+        const options = {
+            appId,
+            url: bundleUrl,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Invalid bundle data' });
+        await expect(createBundleCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+    it('should handle private key file path', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './bundle.zip';
+        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,
+            url: bundleUrl,
+            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(false);
+        // 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(true);
+        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 scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            url: bundleUrl,
+            checksum: testHash,
+            signature: testSignature,
+            artifactType: 'zip',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId });
+        await createBundleCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
+    });
+    it('should handle private key plain text content', async () => {
+        const appId = 'app-123';
+        const bundleUrl = 'https://example.com/bundle.zip';
+        const bundlePath = './bundle.zip';
+        const privateKeyContent = '-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCgxvzJrMCbmtjb\n-----END PRIVATE KEY-----';
+        const testHash = 'test-hash';
+        const testSignature = 'test-signature';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const testBuffer = Buffer.from('test');
+        const options = {
+            appId,
+            url: bundleUrl,
+            path: bundlePath,
+            privateKey: privateKeyContent,
+            artifactType: 'zip',
+            rollout: 1,
+        };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockIsDirectory.mockResolvedValue(false);
+        // 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(true);
+        vi.mocked(mockBuffer.createBufferFromPath).mockResolvedValue(testBuffer);
+        vi.mocked(mockBuffer.createBufferFromString).mockReturnValue(testBuffer);
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(true);
+        vi.mocked(mockPrivateKey.formatPrivateKey).mockReturnValue('formatted-private-key');
+        vi.mocked(mockHash.createHash).mockResolvedValue(testHash);
+        vi.mocked(mockSignature.createSignature).mockResolvedValue(testSignature);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/bundles`, {
+            appId,
+            url: bundleUrl,
+            checksum: testHash,
+            signature: testSignature,
+            artifactType: 'zip',
+            rolloutPercentage: 1,
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: bundleId });
+        await createBundleCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle successfully created.');
+    });
+    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);
+        });
+        // Mock utility functions
+        const mockBuffer = await import('../../../utils/buffer.js');
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
+        await expect(createBundleCommand.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 utility functions
+        const mockBuffer = await import('../../../utils/buffer.js');
+        vi.mocked(mockBuffer.isPrivateKeyContent).mockReturnValue(false);
+        await expect(createBundleCommand.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.');
+    });
+});

package/dist/commands/apps/bundles/delete.js

@@ -1,11 +1,11 @@
-import { defineCommand, defineOptions } from '@robingenz/zli';
-import consola from 'consola';
-import { z } from 'zod';
 import appBundlesService from '../../../services/app-bundles.js';
 import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
 import organizationsService from '../../../services/organizations.js';
-import { getMessageFromUnknownError } from '../../../utils/error.js';
 import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
 export default defineCommand({
     description: 'Delete an app bundle.',
     options: defineOptions(z.object({
@@ -14,6 +14,10 @@ export default defineCommand({
     })),
     action: async (options, args) => {
         let { appId, bundleId } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
+            process.exit(1);
+        }
         // Prompt for missing arguments
         if (!appId) {
             const organizations = await organizationsService.findAll();
@@ -56,17 +60,10 @@ export default defineCommand({
             return;
         }
         // Delete bundle
-        try {
-            await appBundlesService.delete({
-                appId,
-                appBundleId: bundleId,
-            });
-            consola.success('Bundle deleted successfully.');
-        }
-        catch (error) {
-            const message = getMessageFromUnknownError(error);
-            consola.error(message);
-            process.exit(1);
-        }
+        await appBundlesService.delete({
+            appId,
+            appBundleId: bundleId,
+        });
+        consola.success('Bundle deleted successfully.');
     },
 });

package/dist/commands/apps/bundles/delete.test.js

@@ -0,0 +1,139 @@
+import { DEFAULT_API_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import { prompt } 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 deleteBundleCommand from './delete.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+describe('apps-bundles-delete', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    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(() => undefined);
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should delete bundle with provided appId and bundleId after confirmation', async () => {
+        const appId = 'app-123';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const options = { appId, bundleId };
+        mockPrompt.mockResolvedValueOnce(true); // confirmation
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        await deleteBundleCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this bundle?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle deleted successfully.');
+    });
+    it('should not delete bundle when confirmation is declined', async () => {
+        const appId = 'app-123';
+        const bundleId = 'bundle-456';
+        const options = { appId, bundleId };
+        mockPrompt.mockResolvedValueOnce(false); // declined confirmation
+        await deleteBundleCommand.action(options, undefined);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to delete this bundle?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app selection when appId not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const organization = { id: orgId, name: 'Org 1' };
+        const app = { id: appId, name: 'App 1' };
+        const options = { bundleId };
+        const orgsScope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/organizations')
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [organization]);
+        const appsScope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId: orgId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [app]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        mockPrompt
+            .mockResolvedValueOnce(orgId) // organization selection
+            .mockResolvedValueOnce(appId) // app selection
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteBundleCommand.action(options, undefined);
+        expect(orgsScope.isDone()).toBe(true);
+        expect(appsScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle deleted successfully.');
+    });
+    it('should prompt for bundleId when not provided', async () => {
+        const appId = 'app-123';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200);
+        mockPrompt
+            .mockResolvedValueOnce(bundleId) // bundle ID input
+            .mockResolvedValueOnce(true); // confirmation
+        await deleteBundleCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Enter the bundle ID:', { type: 'text' });
+        expect(mockConsola.success).toHaveBeenCalledWith('Bundle deleted successfully.');
+    });
+    it('should handle error when no organizations exist', async () => {
+        const testToken = 'test-token';
+        const options = {};
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/organizations')
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, []);
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`process.exit called with code ${code}`);
+        });
+        try {
+            await deleteBundleCommand.action(options, undefined);
+        }
+        catch (error) {
+            expect(error.message).toBe('process.exit called with code 1');
+        }
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith('You must create an organization before deleting a bundle.');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('should handle API error during deletion', async () => {
+        const appId = 'app-123';
+        const bundleId = 'bundle-456';
+        const testToken = 'test-token';
+        const options = { appId, bundleId };
+        mockPrompt.mockResolvedValueOnce(true);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/bundles/${bundleId}`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(404, { message: 'Bundle not found' });
+        await expect(deleteBundleCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/bundles/update.js

@@ -1,12 +1,11 @@
-import { defineCommand, defineOptions } from '@robingenz/zli';
-import consola from 'consola';
-import { z } from 'zod';
 import appBundlesService from '../../../services/app-bundles.js';
 import appsService from '../../../services/apps.js';
 import authorizationService from '../../../services/authorization-service.js';
 import organizationsService from '../../../services/organizations.js';
-import { getMessageFromUnknownError } from '../../../utils/error.js';
 import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
 export default defineCommand({
     description: 'Update an app bundle.',
     options: defineOptions(z.object({
@@ -78,22 +77,15 @@ export default defineCommand({
             });
         }
         // Update bundle
-        try {
-            await appBundlesService.update({
-                appId,
-                appBundleId: bundleId,
-                maxAndroidAppVersionCode: androidMax,
-                maxIosAppVersionCode: iosMax,
-                minAndroidAppVersionCode: androidMin,
-                minIosAppVersionCode: iosMin,
-                rolloutPercentage: rollout,
-            });
-            consola.success('Bundle updated successfully.');
-        }
-        catch (error) {
-            const message = getMessageFromUnknownError(error);
-            consola.error(message);
-            process.exit(1);
-        }
+        await appBundlesService.update({
+            appId,
+            appBundleId: bundleId,
+            maxAndroidAppVersionCode: androidMax,
+            maxIosAppVersionCode: iosMax,
+            minAndroidAppVersionCode: androidMin,
+            minIosAppVersionCode: iosMin,
+            rolloutPercentage: rollout,
+        });
+        consola.success('Bundle updated successfully.');
     },
 });