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

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

@@ -0,0 +1,123 @@
+import { DEFAULT_API_BASE_URL } from '../../config/consts.js';
+import authorizationService from '../../services/authorization-service.js';
+import { prompt, 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 transferAppCommand from './transfer.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,
+}));
+describe('apps-transfer', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    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 transfer app with provided options after confirmation', async () => {
+        const appId = 'app-123';
+        const organizationId = 'org-456';
+        const testToken = 'test-token';
+        const options = { appId, organizationId };
+        mockPrompt.mockResolvedValueOnce(true);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/transfer`, { organizationId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await transferAppCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to transfer this app?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('App transferred successfully.');
+    });
+    it('should skip confirmation prompt when --yes is provided', async () => {
+        const appId = 'app-123';
+        const organizationId = 'org-456';
+        const testToken = 'test-token';
+        const options = { appId, organizationId, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/transfer`, { organizationId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        await transferAppCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).not.toHaveBeenCalled();
+        expect(mockConsola.success).toHaveBeenCalledWith('App transferred successfully.');
+    });
+    it('should not transfer app when confirmation is declined', async () => {
+        const appId = 'app-123';
+        const organizationId = 'org-456';
+        const options = { appId, organizationId };
+        mockPrompt.mockResolvedValueOnce(false);
+        await transferAppCommand.action(options, undefined);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to transfer this app?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should prompt for app selection when appId not provided', async () => {
+        const orgId = 'org-1';
+        const appId = 'app-1';
+        const targetOrgId = 'org-2';
+        const testToken = 'test-token';
+        const options = { organizationId: targetOrgId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/transfer`, { organizationId: targetOrgId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        mockPrompt.mockResolvedValueOnce(true);
+        await transferAppCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('App transferred successfully.');
+    });
+    it('should prompt for organization selection when organizationId not provided', async () => {
+        const appId = 'app-123';
+        const targetOrgId = 'org-456';
+        const testToken = 'test-token';
+        const options = { appId };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/transfer`, { organizationId: targetOrgId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: appId, name: 'Test App' });
+        mockPromptOrganizationSelection.mockResolvedValueOnce(targetOrgId);
+        mockPrompt.mockResolvedValueOnce(true);
+        await transferAppCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('App transferred successfully.');
+    });
+    it('should handle API error during transfer', async () => {
+        const appId = 'app-123';
+        const organizationId = 'org-456';
+        const testToken = 'test-token';
+        const options = { appId, organizationId };
+        mockPrompt.mockResolvedValueOnce(true);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/transfer`, { organizationId })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'Target organization has reached its app limit.' });
+        await expect(transferAppCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/apps/unlink.js

@@ -0,0 +1,35 @@
+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: 'Disconnect a git repository from an app.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        yes: z.boolean().optional().describe('Skip confirmation prompt.'),
+    }), { y: 'yes' }),
+    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);
+        }
+        if (!options.yes && isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to disconnect the repository?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appsService.unlinkRepository({ appId });
+        consola.success('Repository disconnected successfully.');
+    }),
+});

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

@@ -0,0 +1,99 @@
+import { DEFAULT_API_BASE_URL } from '../../config/consts.js';
+import authorizationService from '../../services/authorization-service.js';
+import { prompt, 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 unlinkCommand from './unlink.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,
+}));
+describe('apps-unlink', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockPrompt = vi.mocked(prompt);
+    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 unlink repository with provided app ID and --yes flag', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/repository`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(204);
+        await unlinkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository disconnected successfully.');
+    });
+    it('should prompt for confirmation when --yes is not provided', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId };
+        mockPrompt.mockResolvedValueOnce(true);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/repository`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(204);
+        await unlinkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Are you sure you want to disconnect the repository?', {
+            type: 'confirm',
+        });
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository disconnected successfully.');
+    });
+    it('should abort when user declines confirmation', async () => {
+        const appId = 'app-123';
+        const options = { appId };
+        mockPrompt.mockResolvedValueOnce(false);
+        await unlinkCommand.action(options, undefined);
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    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 = { yes: true };
+        mockPromptOrganizationSelection.mockResolvedValueOnce(orgId);
+        mockPromptAppSelection.mockResolvedValueOnce(appId);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/repository`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(204);
+        await unlinkCommand.action(options, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockPromptOrganizationSelection).toHaveBeenCalled();
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId);
+        expect(mockConsola.success).toHaveBeenCalledWith('Repository disconnected successfully.');
+    });
+    it('should handle API error', async () => {
+        const appId = 'app-123';
+        const testToken = 'test-token';
+        const options = { appId, yes: true };
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/repository`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(400, { message: 'No repository linked to this app' });
+        await expect(unlinkCommand.action(options, undefined)).rejects.toThrow();
+        expect(scope.isDone()).toBe(true);
+    });
+});

package/dist/commands/manifests/generate.js

@@ -2,7 +2,7 @@ import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import { z } from 'zod';
 export default defineCommand({
-    description: 'Generate a manifest file.',
+    description: 'Generate a manifest file. Deprecated, use `apps:liveupdates:generate-manifest` instead.',
     options: defineOptions(z.object({
         path: z.string().optional().describe('Path to the web assets folder (e.g. `www` or `dist`).'),
     })),

package/dist/index.js

@@ -23,6 +23,9 @@ const config = defineConfig({
         doctor: await import('./commands/doctor.js').then((mod) => mod.default),
         'apps:create': await import('./commands/apps/create.js').then((mod) => mod.default),
         'apps:delete': await import('./commands/apps/delete.js').then((mod) => mod.default),
+        'apps:link': await import('./commands/apps/link.js').then((mod) => mod.default),
+        'apps:transfer': await import('./commands/apps/transfer.js').then((mod) => mod.default),
+        'apps:unlink': await import('./commands/apps/unlink.js').then((mod) => mod.default),
         'apps:builds:cancel': await import('./commands/apps/builds/cancel.js').then((mod) => mod.default),
         'apps:builds:create': await import('./commands/apps/builds/create.js').then((mod) => mod.default),
         'apps:builds:logs': await import('./commands/apps/builds/logs.js').then((mod) => mod.default),

package/dist/services/app-build-sources.js

@@ -0,0 +1,120 @@
+import { MAX_CONCURRENT_PART_UPLOADS } from '../config/index.js';
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+import FormData from 'form-data';
+class AppBuildSourcesServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async createFromFile(dto, onProgress) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources`, { fileSizeInBytes: dto.fileSizeInBytes }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        await this.upload({
+            appBuildSourceId: response.data.id,
+            appId: dto.appId,
+            buffer: dto.buffer,
+            name: dto.name,
+        }, onProgress);
+        return response.data;
+    }
+    async createFromUrl(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources`, { fileUrl: dto.fileUrl }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async completeUpload(dto) {
+        return this.httpClient
+            .post(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-complete&uploadId=${dto.uploadId}`, {
+            parts: dto.parts,
+        }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        })
+            .then((response) => response.data);
+    }
+    async createUpload(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-create`, {}, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async createUploadPart(dto) {
+        const formData = new FormData();
+        formData.append('blob', dto.buffer, { filename: dto.name });
+        formData.append('partNumber', dto.partNumber.toString());
+        return this.httpClient
+            .put(`/v1/apps/${dto.appId}/build-sources/${dto.appBuildSourceId}/upload?action=mpu-uploadpart&uploadId=${dto.uploadId}`, formData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                ...formData.getHeaders(),
+            },
+        })
+            .then((response) => response.data);
+    }
+    async createUploadParts(dto, onProgress) {
+        const uploadedParts = [];
+        const partSize = 10 * 1024 * 1024; // 10 MB
+        const totalParts = Math.ceil(dto.buffer.byteLength / partSize);
+        let partNumber = 0;
+        const uploadNextPart = async () => {
+            if (partNumber >= totalParts) {
+                return;
+            }
+            partNumber++;
+            onProgress?.(partNumber, totalParts);
+            const start = (partNumber - 1) * partSize;
+            const end = Math.min(start + partSize, dto.buffer.byteLength);
+            const partBuffer = dto.buffer.subarray(start, end);
+            const uploadedPart = await this.createUploadPart({
+                appBuildSourceId: dto.appBuildSourceId,
+                appId: dto.appId,
+                buffer: partBuffer,
+                name: dto.name,
+                partNumber,
+                uploadId: dto.uploadId,
+            });
+            uploadedParts.push(uploadedPart);
+            await uploadNextPart();
+        };
+        const uploadPartPromises = Array.from({ length: MAX_CONCURRENT_PART_UPLOADS });
+        for (let i = 0; i < MAX_CONCURRENT_PART_UPLOADS; i++) {
+            uploadPartPromises[i] = uploadNextPart();
+        }
+        await Promise.all(uploadPartPromises);
+        return uploadedParts.sort((a, b) => a.partNumber - b.partNumber);
+    }
+    async upload(dto, onProgress) {
+        // 1. Create a multipart upload
+        const { uploadId } = await this.createUpload({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+        });
+        // 2. Upload the file in parts
+        const parts = await this.createUploadParts({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+            buffer: dto.buffer,
+            name: dto.name,
+            uploadId,
+        }, onProgress);
+        // 3. Complete the upload
+        await this.completeUpload({
+            appBuildSourceId: dto.appBuildSourceId,
+            appId: dto.appId,
+            parts,
+            uploadId,
+        });
+    }
+}
+const appBuildSourcesService = new AppBuildSourcesServiceImpl(httpClient);
+export default appBuildSourcesService;

package/dist/services/app-devices.js

@@ -55,6 +55,14 @@ class AppDevicesServiceImpl {
             },
         });
     }
+    async updateMany(data) {
+        const ids = data.deviceIds.join(',');
+        await this.httpClient.patch(`/v1/apps/${data.appId}/devices?ids=${ids}`, { forcedAppChannelId: data.forcedAppChannelId }, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
 }
 const appDevicesService = new AppDevicesServiceImpl(httpClient);
 export default appDevicesService;

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/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,10 @@ 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'));

package/dist/utils/git.js

@@ -0,0 +1,91 @@
+import { execSync } from 'child_process';
+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 Error('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 Error(`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 Error(`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 Error && error.message.startsWith('Unsupported git provider')) {
+            throw error;
+        }
+    }
+    throw new Error('Could not parse git remote URL.');
+};