@capawesome/cli 4.6.0-dev.80c962a.1774597304 → 4.6.0-dev.8ae803e.1775035527

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

@@ -0,0 +1,285 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import appBuildSourcesService from '../../../services/app-build-sources.js';
+import appBuildsService from '../../../services/app-builds.js';
+import appCertificatesService from '../../../services/app-certificates.js';
+import appDeploymentsService from '../../../services/app-deployments.js';
+import appEnvironmentsService from '../../../services/app-environments.js';
+import { parseKeyValuePairs } from '../../../utils/app-environments.js';
+import { withAuth } from '../../../utils/auth.js';
+import { parseCustomProperties } from '../../../utils/custom-properties.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { waitForJobCompletion } from '../../../utils/job.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import zip from '../../../utils/zip.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new live update by building and deploying web assets using Capawesome Cloud Runners.',
+    options: defineOptions(z.object({
+        androidEq: z.string().optional().describe('The exact Android versionCode for the live update.'),
+        androidMax: z.string().optional().describe('The maximum Android versionCode for the live update.'),
+        androidMin: z.string().optional().describe('The minimum Android versionCode for the live update.'),
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID to create the live update for.'),
+        certificate: z.string().optional().describe('The name of the certificate to use for the build.'),
+        channel: z.string().optional().describe('The name of the channel to deploy to.'),
+        customProperty: z
+            .array(z.string().min(1).max(100))
+            .max(10)
+            .optional()
+            .describe('A custom property to assign to the build. Must be in the format `key=value`. Can be specified multiple times.'),
+        environment: z.string().optional().describe('The name of the environment to use for the build.'),
+        gitRef: z.string().optional().describe('The Git reference (branch, tag, or commit SHA) to build.'),
+        iosEq: z.string().optional().describe('The exact iOS CFBundleVersion for the live update.'),
+        iosMax: z.string().optional().describe('The maximum iOS CFBundleVersion for the live update.'),
+        iosMin: z.string().optional().describe('The minimum iOS CFBundleVersion for the live update.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        path: z.string().optional().describe('Path to local source files to upload.'),
+        rolloutPercentage: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe('The rollout percentage for the deployment (0-100). Default: 100.'),
+        stack: z
+            .enum(['macos-sequoia', 'macos-tahoe'], {
+            message: 'Build stack must be either `macos-sequoia` or `macos-tahoe`.',
+        })
+            .optional()
+            .describe('The build stack to use for the build process.'),
+        url: z.string().optional().describe('URL to a zip file to use as build source.'),
+        variable: z
+            .array(z.string())
+            .optional()
+            .describe('Ad hoc environment variable in key=value format. Can be specified multiple times.'),
+        variableFile: z
+            .string()
+            .optional()
+            .describe('Path to a file containing ad hoc environment variables in .env format.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompts.'),
+    }), { y: 'yes' }),
+    action: withAuth(async (options) => {
+        let { appId, certificate, channel, gitRef, environment, json, stack, path: sourcePath, url } = options;
+        // Validate that path, url, and gitRef cannot be used together
+        if (sourcePath && gitRef) {
+            consola.error('The --path and --git-ref flags cannot be used together.');
+            process.exit(1);
+        }
+        if (url && gitRef) {
+            consola.error('The --url and --git-ref flags cannot be used together.');
+            process.exit(1);
+        }
+        if (url && sourcePath) {
+            consola.error('The --url and --path flags cannot be used together.');
+            process.exit(1);
+        }
+        // Validate url if provided
+        if (url) {
+            consola.warn('The --url option is experimental and may change in the future.');
+        }
+        // Validate path if provided
+        if (sourcePath) {
+            consola.warn('The --path option is experimental and may change in the future.');
+            const resolvedPath = path.resolve(sourcePath);
+            const stat = await fs.stat(resolvedPath).catch(() => null);
+            if (!stat || !stat.isDirectory()) {
+                consola.error('The --path must point to an existing directory.');
+                process.exit(1);
+            }
+            const packageJsonPath = path.join(resolvedPath, 'package.json');
+            const packageJsonStat = await fs.stat(packageJsonPath).catch(() => null);
+            if (!packageJsonStat || !packageJsonStat.isFile()) {
+                consola.error('The directory specified by --path must contain a package.json file.');
+                process.exit(1);
+            }
+        }
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection({ allowCreate: true });
+            appId = await promptAppSelection(organizationId, { allowCreate: true });
+        }
+        // Prompt for git ref if not provided and no path or url specified
+        if (!sourcePath && !url && !gitRef) {
+            if (!isInteractive()) {
+                consola.error('You must provide a git ref, path, or url when running in non-interactive environment.');
+                process.exit(1);
+            }
+            gitRef = await prompt('Enter the Git reference (branch, tag, or commit SHA):', {
+                type: 'text',
+            });
+            if (!gitRef) {
+                consola.error('You must provide a git ref.');
+                process.exit(1);
+            }
+        }
+        // Prompt for channel if not provided
+        if (!channel) {
+            if (!isInteractive()) {
+                consola.error('You must provide a channel when running in non-interactive environment.');
+                process.exit(1);
+            }
+            channel = await prompt('Enter the channel name to deploy to:', {
+                type: 'text',
+            });
+            if (!channel) {
+                consola.error('You must provide a channel.');
+                process.exit(1);
+            }
+        }
+        // Prompt for environment if not provided
+        if (!environment && !options.yes && isInteractive()) {
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectEnvironment = await prompt('Do you want to select an environment?', {
+                type: 'confirm',
+                initial: false,
+            });
+            if (selectEnvironment) {
+                const environments = await appEnvironmentsService.findAll({ appId });
+                if (environments.length === 0) {
+                    consola.warn('No environments found for this app.');
+                }
+                else {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    environment = await prompt('Select the environment for the build:', {
+                        type: 'select',
+                        options: environments.map((env) => ({ label: env.name, value: env.name })),
+                    });
+                }
+            }
+        }
+        // Prompt for certificate if not provided
+        if (!certificate && !options.yes && isInteractive()) {
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectCertificate = await prompt('Do you want to select a certificate?', {
+                type: 'confirm',
+                initial: false,
+            });
+            if (selectCertificate) {
+                const certificates = await appCertificatesService.findAll({ appId, platform: 'web' });
+                if (certificates.length === 0) {
+                    consola.warn('No certificates found for this app.');
+                }
+                else {
+                    // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+                    certificate = await prompt('Select the certificate for the build:', {
+                        type: 'select',
+                        options: certificates.map((cert) => ({ label: cert.name, value: cert.name })),
+                    });
+                }
+            }
+        }
+        // Parse ad hoc environment variables from inline and file
+        const variablesMap = new Map();
+        if (options.variableFile) {
+            const fileContent = await fs.readFile(options.variableFile, 'utf-8');
+            const fileVariables = parseKeyValuePairs(fileContent);
+            fileVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        if (options.variable) {
+            const inlineVariables = parseKeyValuePairs(options.variable.join('\n'));
+            inlineVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        const adHocEnvironmentVariables = variablesMap.size > 0 ? Object.fromEntries(variablesMap) : undefined;
+        // Create build source from URL if provided
+        let appBuildSourceId;
+        if (url) {
+            consola.start('Creating build source from URL...');
+            const appBuildSource = await appBuildSourcesService.createFromUrl({ appId, fileUrl: url });
+            appBuildSourceId = appBuildSource.id;
+            consola.success('Build source created successfully.');
+        }
+        // Upload source files if path is provided
+        if (sourcePath) {
+            const resolvedPath = path.resolve(sourcePath);
+            consola.start('Zipping source files...');
+            const buffer = await zip.zipFolderWithGitignore(resolvedPath);
+            consola.start('Uploading source files...');
+            const appBuildSource = await appBuildSourcesService.createFromFile({
+                appId,
+                fileSizeInBytes: buffer.byteLength,
+                buffer,
+                name: 'source.zip',
+            }, (currentPart, totalParts) => {
+                consola.start(`Uploading source files (${currentPart}/${totalParts})...`);
+            });
+            appBuildSourceId = appBuildSource.id;
+            consola.success('Source files uploaded successfully.');
+        }
+        // Create the web build
+        consola.start('Creating build...');
+        const response = await appBuildsService.create({
+            adHocEnvironmentVariables,
+            appBuildSourceId,
+            appCertificateName: certificate,
+            appEnvironmentName: environment,
+            appId,
+            stack,
+            gitRef,
+            platform: 'web',
+        });
+        consola.info(`Build ID: ${response.id}`);
+        consola.info(`Build Number: ${response.numberAsString}`);
+        consola.info(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${response.id}`);
+        consola.success('Build created successfully.');
+        // Wait for build to complete
+        await waitForJobCompletion({ jobId: response.jobId });
+        consola.success('Build completed successfully.');
+        console.log();
+        // Update build with custom properties and version constraints if any are provided
+        const customProperties = parseCustomProperties(options.customProperty);
+        const hasUpdateFields = customProperties ||
+            options.androidMin ||
+            options.androidMax ||
+            options.androidEq ||
+            options.iosMin ||
+            options.iosMax ||
+            options.iosEq;
+        if (hasUpdateFields) {
+            consola.start('Updating build...');
+            await appBuildsService.update({
+                appId,
+                appBuildId: response.id,
+                customProperties,
+                minAndroidAppVersionCode: options.androidMin,
+                maxAndroidAppVersionCode: options.androidMax,
+                eqAndroidAppVersionCode: options.androidEq,
+                minIosAppVersionCode: options.iosMin,
+                maxIosAppVersionCode: options.iosMax,
+                eqIosAppVersionCode: options.iosEq,
+            });
+            consola.success('Build updated successfully.');
+        }
+        // Deploy to channel
+        consola.start('Creating deployment...');
+        const rolloutPercentage = (options.rolloutPercentage ?? 100) / 100;
+        const deployment = await appDeploymentsService.create({
+            appId,
+            appBuildId: response.id,
+            appChannelName: channel,
+            rolloutPercentage,
+        });
+        consola.info(`Deployment ID: ${deployment.id}`);
+        consola.info(`Deployment URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/deployments/${deployment.id}`);
+        consola.success('Deployment created successfully.');
+        // Output JSON if json flag is set
+        if (json) {
+            console.log(JSON.stringify({
+                buildId: response.id,
+                buildNumberAsString: response.numberAsString,
+                deploymentId: deployment.id,
+            }, null, 2));
+        }
+    }),
+});

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

@@ -0,0 +1,262 @@
+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 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',
+            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 a 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.');
+    });
 });