@capawesome/cli 4.6.0-dev.bda9e9d.1774345600 → 4.7.0

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 { directoryContainsSourceMaps, 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,11 +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 { directoryContainsSourceMaps, 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,13 @@ 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);
@@ -290,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({
@@ -377,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/apps/transfer.js

@@ -0,0 +1,47 @@
+import appsService from '../../services/apps.js';
+import { withAuth } from '../../utils/auth.js';
+import { isInteractive } from '../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Transfer an app to another organization.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        organizationId: z.string().optional().describe('ID of the target organization.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompt.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options, args) => {
+        let { appId, organizationId } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide the app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const sourceOrganizationId = await promptOrganizationSelection({
+                message: 'Which organization does the app belong to?',
+            });
+            appId = await promptAppSelection(sourceOrganizationId);
+        }
+        if (!organizationId) {
+            if (!isInteractive()) {
+                consola.error('You must provide the organization ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            organizationId = await promptOrganizationSelection({
+                message: 'Which organization do you want to transfer the app to?',
+            });
+        }
+        if (!options.yes && isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to transfer this app?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appsService.transfer({ appId, organizationId });
+        consola.success('App transferred successfully.');
+    }),
+});