@capawesome/cli 4.6.0 → 4.8.0-dev.efa0850.1775645973

package/dist/services/apps.js

@@ -42,6 +42,31 @@ class AppsServiceImpl {
         });
         return response.data;
     }
+    async linkRepository(dto) {
+        const { appId, ...bodyData } = dto;
+        const response = await this.httpClient.put(`/v1/apps/${appId}/repository`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async transfer(dto) {
+        const { appId, ...bodyData } = dto;
+        const response = await this.httpClient.post(`/v1/apps/${appId}/transfer`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async unlinkRepository(dto) {
+        await this.httpClient.delete(`/v1/apps/${dto.appId}/repository`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
 }
 const appsService = new AppsServiceImpl(httpClient);
 export default appsService;

package/dist/services/authorization-service.js

@@ -5,7 +5,11 @@ class AuthorizationServiceImpl {
         this.userConfig = userConfig;
     }
     getCurrentAuthorizationToken() {
-        return this.userConfig.read().token || process.env.CAPAWESOME_CLOUD_TOKEN || process.env.CAPAWESOME_TOKEN || null;
+        const token = this.userConfig.read().token || process.env.CAPAWESOME_CLOUD_TOKEN || process.env.CAPAWESOME_TOKEN || null;
+        // Trim to remove newline characters that may be included when pasting a token,
+        // which would cause an invalid character error in the Authorization header.
+        const trimmedToken = token?.trim();
+        return trimmedToken || null;
     }
     hasAuthorizationToken() {
         return !!this.getCurrentAuthorizationToken();

package/dist/services/jobs.js

@@ -5,6 +5,19 @@ class JobsServiceImpl {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
+    async findOne(dto) {
+        const params = {};
+        if (dto.relations) {
+            params.relations = dto.relations;
+        }
+        const response = await this.httpClient.get(`/v1/jobs/${dto.jobId}`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
     async update(options) {
         const { jobId, dto } = options;
         const response = await this.httpClient.patch(`/v1/jobs/${jobId}`, dto, {

package/dist/types/app-build-source.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.js

@@ -1,4 +1,5 @@
 export * from './app-apple-api-key.js';
+export * from './app-build-source.js';
 export * from './app-bundle.js';
 export * from './app-certificate.js';
 export * from './app-channel.js';

package/dist/utils/custom-properties.js

@@ -0,0 +1,22 @@
+export const parseCustomProperties = (customProperty) => {
+    if (!customProperty) {
+        return undefined;
+    }
+    const customProperties = {};
+    for (const property of customProperty) {
+        if (!property) {
+            continue;
+        }
+        const separatorIndex = property.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = property.slice(0, separatorIndex).trim();
+        const value = property.slice(separatorIndex + 1).trim();
+        if (!key || !value) {
+            continue;
+        }
+        customProperties[key] = value;
+    }
+    return Object.keys(customProperties).length > 0 ? customProperties : undefined;
+};

package/dist/utils/error.js

@@ -1,5 +1,11 @@
 import { AxiosError } from 'axios';
 import { ZodError } from 'zod';
+export class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UserError';
+    }
+}
 export const getMessageFromUnknownError = (error) => {
     let message = 'An unknown error has occurred.';
     if (error instanceof AxiosError) {

package/dist/utils/file.js

@@ -7,7 +7,10 @@ export const getFilesInDirectoryAndSubdirectories = async (path) => {
         const dirEntries = await fs.promises.readdir(directory, { withFileTypes: true }).catch(() => []);
         for (const dirEntry of dirEntries) {
             const fullPath = pathModule.join(directory, dirEntry.name);
-            if (dirEntry.isDirectory()) {
+            if (dirEntry.isSymbolicLink()) {
+                // Skip symlinks
+            }
+            else if (dirEntry.isDirectory()) {
                 await walk(fullPath);
             }
             else {
@@ -35,6 +38,14 @@ export const getFilesInDirectoryAndSubdirectories = async (path) => {
     await walk(path);
     return files;
 };
+export const directoryContainsSymlinks = async (path) => {
+    const dirEntries = await fs.promises.readdir(path, { withFileTypes: true, recursive: true }).catch(() => []);
+    return dirEntries.some((dirEntry) => dirEntry.isSymbolicLink());
+};
+export const directoryContainsSourceMaps = async (path) => {
+    const files = await getFilesInDirectoryAndSubdirectories(path);
+    return files.some((file) => file.name.endsWith('.js.map') || file.name.endsWith('.css.map'));
+};
 export const fileExistsAtPath = async (path) => {
     return new Promise((resolve) => {
         fs.access(path, fs.constants.F_OK, (err) => {

package/dist/utils/git.js

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process';
+import { UserError } from '../utils/error.js';
+const HOSTNAME_TO_PROVIDER = {
+    'github.com': 'github',
+    'gitlab.com': 'gitlab',
+    'bitbucket.org': 'bitbucket',
+    'dev.azure.com': 'azure',
+    'ssh.dev.azure.com': 'azure',
+};
+export const getGitRemoteInfo = () => {
+    const remoteUrl = getGitRemoteUrl();
+    return parseGitRemoteUrl(remoteUrl);
+};
+const getGitRemoteUrl = () => {
+    try {
+        return execSync('git remote get-url origin', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        throw new UserError('Could not read the git remote URL. Make sure you are inside a git repository with an origin remote.');
+    }
+};
+export const parseGitRemoteUrl = (remoteUrl) => {
+    // Azure DevOps HTTPS: https://dev.azure.com/{org}/{project}/_git/{repo}
+    const azureHttpsMatch = remoteUrl.match(/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?$/);
+    if (azureHttpsMatch && azureHttpsMatch[1] && azureHttpsMatch[2] && azureHttpsMatch[3]) {
+        return {
+            ownerSlug: azureHttpsMatch[1],
+            provider: 'azure',
+            repositorySlug: azureHttpsMatch[3],
+            projectSlug: azureHttpsMatch[2],
+        };
+    }
+    // Azure DevOps SSH: git@ssh.dev.azure.com:v3/{org}/{project}/{repo}
+    const azureSshMatch = remoteUrl.match(/ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (azureSshMatch && azureSshMatch[1] && azureSshMatch[2] && azureSshMatch[3]) {
+        return {
+            ownerSlug: azureSshMatch[1],
+            provider: 'azure',
+            repositorySlug: azureSshMatch[3],
+            projectSlug: azureSshMatch[2],
+        };
+    }
+    // Visual Studio HTTPS: https://{org}.visualstudio.com/{project}/_git/{repo}
+    const vsHttpsMatch = remoteUrl.match(/([^/]+)\.visualstudio\.com\/([^/]+)\/_git\/([^/]+?)(?:\.git)?$/);
+    if (vsHttpsMatch && vsHttpsMatch[1] && vsHttpsMatch[2] && vsHttpsMatch[3]) {
+        return {
+            ownerSlug: vsHttpsMatch[1],
+            provider: 'azure',
+            repositorySlug: vsHttpsMatch[3],
+            projectSlug: vsHttpsMatch[2],
+        };
+    }
+    // SSH: git@{host}:{owner}[/{subgroup}]/{repo}.git
+    const sshMatch = remoteUrl.match(/git@([^:]+):([^/]+)(?:\/([^/]+))?\/([^/]+?)(?:\.git)?$/);
+    if (sshMatch && sshMatch[1] && sshMatch[2] && sshMatch[4]) {
+        const hostname = sshMatch[1];
+        const provider = HOSTNAME_TO_PROVIDER[hostname];
+        if (!provider) {
+            throw new UserError(`Unsupported git provider for hostname "${hostname}".`);
+        }
+        return {
+            ownerSlug: sshMatch[2],
+            provider,
+            repositorySlug: sshMatch[4],
+            projectSlug: sshMatch[3],
+        };
+    }
+    // HTTPS: https://[user@]{host}/{owner}[/{subgroup}]/{repo}.git
+    try {
+        const url = new URL(remoteUrl);
+        if (url.protocol === 'http:' || url.protocol === 'https:') {
+            const hostname = url.hostname;
+            const provider = HOSTNAME_TO_PROVIDER[hostname];
+            if (!provider) {
+                throw new UserError(`Unsupported git provider for hostname "${hostname}".`);
+            }
+            const pathSegments = url.pathname.split('/').filter(Boolean);
+            const repositorySlug = pathSegments.pop()?.replace(/\.git$/, '');
+            const ownerSlug = pathSegments.shift();
+            const projectSlug = pathSegments.length > 0 ? pathSegments.join('/') : undefined;
+            if (ownerSlug && repositorySlug) {
+                return { ownerSlug, provider, repositorySlug, projectSlug };
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof UserError) {
+            throw error;
+        }
+    }
+    throw new UserError('Could not parse git remote URL.');
+};

package/dist/utils/git.test.js

@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import { parseGitRemoteUrl } from './git.js';
+describe('parseGitRemoteUrl', () => {
+    it('should parse GitHub HTTPS URL', () => {
+        const result = parseGitRemoteUrl('https://github.com/capawesome-team/cli.git');
+        expect(result).toEqual({
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        });
+    });
+    it('should parse GitHub HTTPS URL without .git suffix', () => {
+        const result = parseGitRemoteUrl('https://github.com/capawesome-team/cli');
+        expect(result).toEqual({
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        });
+    });
+    it('should parse GitHub SSH URL', () => {
+        const result = parseGitRemoteUrl('git@github.com:capawesome-team/cli.git');
+        expect(result).toEqual({
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        });
+    });
+    it('should parse GitHub SSH URL without .git suffix', () => {
+        const result = parseGitRemoteUrl('git@github.com:capawesome-team/cli');
+        expect(result).toEqual({
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        });
+    });
+    it('should parse GitLab HTTPS URL', () => {
+        const result = parseGitRemoteUrl('https://gitlab.com/my-group/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-group',
+            provider: 'gitlab',
+            repositorySlug: 'my-repo',
+        });
+    });
+    it('should parse GitLab SSH URL', () => {
+        const result = parseGitRemoteUrl('git@gitlab.com:my-group/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-group',
+            provider: 'gitlab',
+            repositorySlug: 'my-repo',
+        });
+    });
+    it('should parse GitLab HTTPS URL with subgroup', () => {
+        const result = parseGitRemoteUrl('https://gitlab.com/my-group/my-subgroup/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-group',
+            provider: 'gitlab',
+            repositorySlug: 'my-repo',
+            projectSlug: 'my-subgroup',
+        });
+    });
+    it('should parse GitLab SSH URL with subgroup', () => {
+        const result = parseGitRemoteUrl('git@gitlab.com:my-group/my-subgroup/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-group',
+            provider: 'gitlab',
+            repositorySlug: 'my-repo',
+            projectSlug: 'my-subgroup',
+        });
+    });
+    it('should parse Bitbucket HTTPS URL', () => {
+        const result = parseGitRemoteUrl('https://bitbucket.org/my-team/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-team',
+            provider: 'bitbucket',
+            repositorySlug: 'my-repo',
+        });
+    });
+    it('should parse Bitbucket SSH URL', () => {
+        const result = parseGitRemoteUrl('git@bitbucket.org:my-team/my-repo.git');
+        expect(result).toEqual({
+            ownerSlug: 'my-team',
+            provider: 'bitbucket',
+            repositorySlug: 'my-repo',
+        });
+    });
+    it('should parse Azure DevOps HTTPS URL', () => {
+        const result = parseGitRemoteUrl('https://dev.azure.com/my-org/my-project/_git/my-repo');
+        expect(result).toEqual({
+            ownerSlug: 'my-org',
+            provider: 'azure',
+            repositorySlug: 'my-repo',
+            projectSlug: 'my-project',
+        });
+    });
+    it('should parse Azure DevOps SSH URL', () => {
+        const result = parseGitRemoteUrl('git@ssh.dev.azure.com:v3/my-org/my-project/my-repo');
+        expect(result).toEqual({
+            ownerSlug: 'my-org',
+            provider: 'azure',
+            repositorySlug: 'my-repo',
+            projectSlug: 'my-project',
+        });
+    });
+    it('should parse Visual Studio HTTPS URL', () => {
+        const result = parseGitRemoteUrl('https://my-org.visualstudio.com/my-project/_git/my-repo');
+        expect(result).toEqual({
+            ownerSlug: 'my-org',
+            provider: 'azure',
+            repositorySlug: 'my-repo',
+            projectSlug: 'my-project',
+        });
+    });
+    it('should parse GitHub HTTPS URL with credentials', () => {
+        const result = parseGitRemoteUrl('https://x-access-token:ghp_secret123@github.com/capawesome-team/cli.git');
+        expect(result).toEqual({
+            ownerSlug: 'capawesome-team',
+            provider: 'github',
+            repositorySlug: 'cli',
+        });
+    });
+    it('should throw for unsupported hostname', () => {
+        expect(() => parseGitRemoteUrl('https://example.com/owner/repo.git')).toThrow('Unsupported git provider for hostname "example.com".');
+    });
+    it('should not leak credentials in error messages', () => {
+        expect(() => parseGitRemoteUrl('https://token@example.com/owner/repo.git')).toThrow('Unsupported git provider for hostname "example.com".');
+    });
+    it('should throw for unparseable URL', () => {
+        expect(() => parseGitRemoteUrl('not-a-url')).toThrow('Could not parse git remote URL.');
+    });
+});

package/dist/utils/job.js

@@ -0,0 +1,77 @@
+import jobsService from '../services/jobs.js';
+import { unescapeAnsi } from '../utils/ansi.js';
+import { wait } from '../utils/wait.js';
+import consola from 'consola';
+const getLabel = (job) => {
+    if (job.appBuildId) {
+        return 'build';
+    }
+    if (job.appDeploymentId) {
+        return 'deployment';
+    }
+    return 'job';
+};
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+export const waitForJobCompletion = async (options) => {
+    const { jobId } = options;
+    let lastPrintedLogNumber = 0;
+    let isWaitingForStart = true;
+    while (true) {
+        try {
+            const job = await jobsService.findOne({ jobId, relations: 'jobLogs' });
+            const label = getLabel(job);
+            const jobStatus = job.status;
+            if (jobStatus === 'queued' || jobStatus === 'pending') {
+                if (isWaitingForStart) {
+                    consola.start(`Waiting for ${label} to start (status: ${jobStatus})...`);
+                }
+                await wait(3000);
+                continue;
+            }
+            if (isWaitingForStart && jobStatus === 'in_progress') {
+                isWaitingForStart = false;
+                consola.success(`${capitalize(label)} started...`);
+            }
+            if (job.jobLogs && job.jobLogs.length > 0) {
+                const newLogs = job.jobLogs
+                    .filter((log) => log.number > lastPrintedLogNumber)
+                    .sort((a, b) => a.number - b.number);
+                for (const log of newLogs) {
+                    console.log(unescapeAnsi(log.payload));
+                    lastPrintedLogNumber = log.number;
+                }
+            }
+            if (jobStatus === 'succeeded' ||
+                jobStatus === 'failed' ||
+                jobStatus === 'canceled' ||
+                jobStatus === 'rejected' ||
+                jobStatus === 'timed_out') {
+                console.log();
+                if (jobStatus === 'succeeded') {
+                    return job;
+                }
+                else if (jobStatus === 'failed') {
+                    consola.error(`${capitalize(label)} failed.`);
+                    process.exit(1);
+                }
+                else if (jobStatus === 'canceled') {
+                    consola.error(`${capitalize(label)} was canceled.`);
+                    process.exit(1);
+                }
+                else if (jobStatus === 'rejected') {
+                    consola.error(`${capitalize(label)} was rejected.`);
+                    process.exit(1);
+                }
+                else if (jobStatus === 'timed_out') {
+                    consola.error(`${capitalize(label)} timed out.`);
+                    process.exit(1);
+                }
+            }
+            await wait(3000);
+        }
+        catch (error) {
+            consola.error('Error polling job status:', error);
+            process.exit(1);
+        }
+    }
+};

package/dist/utils/prompt.js

@@ -31,7 +31,7 @@ export const promptOrganizationSelection = async (options) => {
         }
     }
     // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
-    const organizationId = await prompt('Which organization do you want to use?', {
+    const organizationId = await prompt(options?.message ?? 'Which organization do you want to use?', {
         type: 'select',
         options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
     });

package/dist/utils/zip.js

@@ -1,12 +1,29 @@
 import AdmZip from 'adm-zip';
+import { globby } from 'globby';
+import path from 'path';
 class ZipImpl {
     async zipFolder(sourceFolder) {
         const zip = new AdmZip();
         zip.addLocalFolder(sourceFolder);
         return zip.toBuffer();
     }
-    isZipped(path) {
-        return path.endsWith('.zip');
+    async zipFolderWithGitignore(sourceFolder) {
+        const files = await globby(['**/*'], {
+            cwd: sourceFolder,
+            gitignore: true,
+            ignore: ['.git/**'],
+            dot: true,
+        });
+        const zip = new AdmZip();
+        for (const file of files) {
+            const filePath = path.join(sourceFolder, file);
+            const dirName = path.dirname(file);
+            zip.addLocalFile(filePath, dirName === '.' ? '' : dirName);
+        }
+        return zip.toBuffer();
+    }
+    isZipped(filePath) {
+        return filePath.endsWith('.zip');
     }
 }
 const zip = new ZipImpl();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "4.6.0",
+  "version": "4.8.0-dev.efa0850.1775645973",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {
@@ -61,6 +61,7 @@
     "c12": "3.3.3",
     "consola": "3.3.0",
     "form-data": "4.0.4",
+    "globby": "16.1.1",
     "http-proxy-agent": "7.0.2",
     "https-proxy-agent": "7.0.6",
     "mime": "4.0.7",