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

package/dist/commands/apps/link.js

@@ -0,0 +1,34 @@
+import appsService from '../../services/apps.js';
+import { withAuth } from '../../utils/auth.js';
+import { isInteractive } from '../../utils/environment.js';
+import { getGitRemoteInfo } from '../../utils/git.js';
+import { promptAppSelection, promptOrganizationSelection } from '../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Connect a git repository to an app.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+    })),
+    action: withAuth(async (options, args) => {
+        let { appId } = options;
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide the app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        const gitRemoteInfo = getGitRemoteInfo();
+        await appsService.linkRepository({
+            appId,
+            ownerSlug: gitRemoteInfo.ownerSlug,
+            provider: gitRemoteInfo.provider,
+            repositorySlug: gitRemoteInfo.repositorySlug,
+            projectSlug: gitRemoteInfo.projectSlug,
+        });
+        consola.success('Repository connected successfully.');
+    }),
+});

package/dist/commands/apps/link.test.js

@@ -0,0 +1,94 @@
+import { DEFAULT_API_BASE_URL } from '../../config/consts.js';
+import authorizationService from '../../services/authorization-service.js';
+import { promptAppSelection, promptOrganizationSelection } 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 linkCommand from './link.js';
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => true,
+}));
+vi.mock('@/utils/git.js', () => ({
+    getGitRemoteInfo: () => ({
+        ownerSlug: 'capawesome-team',
+        provider: 'github',
+        repositorySlug: 'cli',
+    }),
+}));
+describe('apps-link', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPromptOrganizationSelection = vi.mocked(promptOrganizationSelection);
+    const mockPromptAppSelection = vi.mocked(promptAppSelection);
+    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((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should link repository with provided app ID', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await linkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
+    });
+    it('should prompt for organization and app when app ID is not provided', async () => {
+        const appId = 'app-123';
+        const orgId = 'org-1';
+        const testToken = 'test-token';
+        const options = {};
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await linkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPromptOrganizationSelection).toHaveBeenCalled();
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, {
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Git provider not connected' });
+        await expect(linkCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

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

@@ -1,5 +1,5 @@
 import { isInteractive } from '../../../utils/environment.js';
-import { directoryContainsSourceMaps, fileExistsAtPath, isDirectory } 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 zip from '../../../utils/zip.js';
@@ -9,7 +9,7 @@ import fs from 'fs';
 import pathModule from 'path';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Generate manifest file and compress web assets into a bundle.zip file.',
+    description: 'Generate manifest file and compress locally built web assets into a bundle.zip file.',
     options: defineOptions(z.object({
         inputPath: z.string().optional().describe('Path to the web assets directory.'),
         outputPath: z
@@ -62,6 +62,11 @@ export default defineCommand({
             consola.error(`Directory must contain an index.html file: ${inputPath}`);
             process.exit(1);
         }
+        // Check for symlinks
+        const containsSymlinks = await directoryContainsSymlinks(inputPath);
+        if (containsSymlinks) {
+            consola.warn('Symbolic links were detected in the specified path. Symbolic links are skipped during bundling.');
+        }
         // Check for source maps
         const containsSourceMaps = await directoryContainsSourceMaps(inputPath);
         if (containsSourceMaps) {

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

@@ -1,18 +1,27 @@
 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 appDeploymentsService from '../../../services/app-deployments.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 { waitForBuildCompletion } from '../../../utils/build.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.',
+    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.',
@@ -20,33 +29,81 @@ export default defineCommand({
             .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.'),
-        gitRef: z.string().optional().describe('The Git reference (branch, tag, or commit SHA) to build.'),
-        environment: z.string().optional().describe('The name of the environment to use for the build.'),
-        stack: z
-            .enum(['macos-sequoia', 'macos-tahoe'], {
-            message: 'Build stack must be either `macos-sequoia` or `macos-tahoe`.',
-        })
+        channel: z
+            .array(z.string())
             .optional()
-            .describe('The build stack to use for the build process.'),
-        androidMin: z.string().optional().describe('The minimum Android versionCode for the live update.'),
-        androidMax: z.string().optional().describe('The maximum Android versionCode for the live update.'),
-        androidEq: z.string().optional().describe('The exact Android versionCode for the live update.'),
-        iosMin: z.string().optional().describe('The minimum iOS CFBundleVersion for the live update.'),
-        iosMax: z.string().optional().describe('The maximum iOS CFBundleVersion for the live update.'),
+            .describe('The name of the channel to deploy to. Can be specified multiple times.'),
+        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.'),
-        rolloutPercentage: z
+        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.'),
-        json: z.boolean().optional().describe('Output in JSON format.'),
+        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 } = 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()) {
@@ -56,10 +113,10 @@ export default defineCommand({
             const organizationId = await promptOrganizationSelection({ allowCreate: true });
             appId = await promptAppSelection(organizationId, { allowCreate: true });
         }
-        // Prompt for git ref if not provided
-        if (!gitRef) {
+        // 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 when running in non-interactive environment.');
+                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):', {
@@ -71,18 +128,19 @@ export default defineCommand({
             }
         }
         // Prompt for channel if not provided
-        if (!channel) {
+        if (!channel || channel.length === 0) {
             if (!isInteractive()) {
-                consola.error('You must provide a channel when running in non-interactive environment.');
+                consola.error('You must provide at least one channel when running in non-interactive environment.');
                 process.exit(1);
             }
-            channel = await prompt('Enter the channel name to deploy to:', {
+            const channelName = await prompt('Enter the channel name to deploy to:', {
                 type: 'text',
             });
-            if (!channel) {
+            if (!channelName) {
                 consola.error('You must provide a channel.');
                 process.exit(1);
             }
+            channel = [channelName];
         }
         // Prompt for environment if not provided
         if (!environment && !options.yes && isInteractive()) {
@@ -126,9 +184,48 @@ export default defineCommand({
                 }
             }
         }
+        // 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,
@@ -141,21 +238,24 @@ export default defineCommand({
         consola.info(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${response.id}`);
         consola.success('Build created successfully.');
         // Wait for build to complete
-        await waitForBuildCompletion({ appId, appBuildId: response.id });
+        await waitForJobCompletion({ jobId: response.jobId });
         consola.success('Build completed successfully.');
         console.log();
-        // Update build with version constraints if any are provided
-        const hasVersionConstraints = options.androidMin ||
+        // 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 (hasVersionConstraints) {
-            consola.start('Updating version constraints...');
+        if (hasUpdateFields) {
+            consola.start('Updating build...');
             await appBuildsService.update({
                 appId,
                 appBuildId: response.id,
+                customProperties,
                 minAndroidAppVersionCode: options.androidMin,
                 maxAndroidAppVersionCode: options.androidMax,
                 eqAndroidAppVersionCode: options.androidEq,
@@ -163,26 +263,30 @@ export default defineCommand({
                 maxIosAppVersionCode: options.iosMax,
                 eqIosAppVersionCode: options.iosEq,
             });
-            consola.success('Version constraints updated successfully.');
+            consola.success('Build updated successfully.');
         }
-        // Deploy to channel
-        consola.start('Creating deployment...');
+        // Deploy to channels
         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.');
+        const deploymentIds = [];
+        for (const channelName of channel) {
+            consola.start(`Creating deployment for channel "${channelName}"...`);
+            const deployment = await appDeploymentsService.create({
+                appId,
+                appBuildId: response.id,
+                appChannelName: channelName,
+                rolloutPercentage,
+            });
+            deploymentIds.push(deployment.id);
+            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,
+                deploymentIds,
             }, null, 2));
         }
     }),