@capawesome/cli 4.19.0 → 4.21.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [4.21.0](https://github.com/capawesome-team/cli/compare/v4.20.0...v4.21.0) (2026-09-22)
+
+
+### Features
+
+* **apps:** link repositories via git connections ([#222](https://github.com/capawesome-team/cli/issues/222)) ([f567ea6](https://github.com/capawesome-team/cli/commit/f567ea6d0e836b4aea8e4d57ff10d934a6788fe2))
+
+
+### Bug Fixes
+
+* retry rate limited requests ([#223](https://github.com/capawesome-team/cli/issues/223)) ([47d9733](https://github.com/capawesome-team/cli/commit/47d9733ec28bf0bb3235b8dccdd5b353ec24d0b5))
+
+## [4.20.0](https://github.com/capawesome-team/cli/compare/v4.19.0...v4.20.0) (2026-09-22)
+
+
+### Features
+
+* **apps:** warn about missing git connections before importing apps ([#221](https://github.com/capawesome-team/cli/issues/221)) ([2b4646d](https://github.com/capawesome-team/cli/commit/2b4646d4c2cbcc3c8dd54c68021a9f1ed47c9521))
+
+
+### Bug Fixes
+
+* **apps:** remove extracted export on cancelled prompts and signals ([#219](https://github.com/capawesome-team/cli/issues/219)) ([0356500](https://github.com/capawesome-team/cli/commit/035650041f456d5831ecf2fff8cee5fb231db8db))
+* **apps:** rename imported resources whose names only differ in case ([#218](https://github.com/capawesome-team/cli/issues/218)) ([135b577](https://github.com/capawesome-team/cli/commit/135b577e86620dd71d9297a4124a2db2fd1cf15f))
+
 ## [4.19.0](https://github.com/capawesome-team/cli/compare/v4.18.4...v4.19.0) (2026-09-22)
 
 

package/dist/commands/apps/import.js

@@ -8,12 +8,14 @@ import appEnvironmentsService from '../../services/app-environments.js';
 import appGoogleServiceAccountKeysService from '../../services/app-google-service-account-keys.js';
 import appProvisioningProfilesService from '../../services/app-provisioning-profiles.js';
 import appsService from '../../services/apps.js';
-import { generateUniqueAppName } from '../../utils/app-import.js';
+import gitConnectionsService from '../../services/git-connections.js';
+import { generateUniqueName, isNameTaken } from '../../utils/app-import.js';
 import { parseAppflowExport } from '../../utils/appflow-export.js';
 import { withAuth } from '../../utils/auth.js';
 import { isInteractive } from '../../utils/environment.js';
 import { getMessageFromUnknownError, UserError } from '../../utils/error.js';
 import { isReadable } from '../../utils/file.js';
+import { getGitRepositoryPath } from '../../utils/git.js';
 import { prompt, promptOrganizationSelection } from '../../utils/prompt.js';
 import zip from '../../utils/zip.js';
 import { defineCommand, defineOptions } from 'zodline';
@@ -22,6 +24,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { z } from 'zod';
+const SIGNALS = ['SIGHUP', 'SIGINT', 'SIGTERM'];
 export default defineCommand({
     description: 'Import apps from an Ionic Appflow export.',
     options: defineOptions(z.object({
@@ -72,6 +75,19 @@ export default defineCommand({
             });
         }
         const tempDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'capawesome-appflow-import-'));
+        // The extracted export contains secrets, so it must also be removed when the
+        // process exits via `process.exit` (e.g. a cancelled prompt) or a signal,
+        // which would skip the `finally` block.
+        const removeTempDirectory = () => fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 3 });
+        const handleSignal = (signal) => {
+            removeTempDirectory();
+            // Re-raise the signal to keep the default exit code (128 + signal number).
+            process.kill(process.pid, signal);
+        };
+        process.once('exit', removeTempDirectory);
+        for (const signal of SIGNALS) {
+            process.once(signal, handleSignal);
+        }
         try {
             await zip.unzipToFolder(fs.readFileSync(file), tempDirectory);
             const { apps, skippedApps, warnings } = await parseAppflowExport(tempDirectory);
@@ -85,6 +101,14 @@ export default defineCommand({
             const { resolvedApps, skippedApps: unresolvedApps } = await resolveIonicAppTypes(selectedApps, ionicAppType);
             selectedSkippedApps.push(...unresolvedApps);
             await assignUniqueAppNames(resolvedApps, organizationId);
+            const gitConnectionIds = await findGitConnectionIds(resolvedApps, organizationId);
+            for (const provider of getGitProviders(resolvedApps)) {
+                if (gitConnectionIds.has(provider)) {
+                    continue;
+                }
+                const appCount = resolvedApps.filter((app) => app.repository?.provider === provider).length;
+                consola.warn(`The organization has no \`${provider}\` git connection, so the repositories of ${appCount} app(s) will not be linked. Connect the git provider at ${DEFAULT_CONSOLE_BASE_URL}/organizations/${organizationId}/git before running the import to link them automatically, or link the repositories manually in the Capawesome Cloud Console afterwards.`);
+            }
             const outcomes = [];
             for (const app of resolvedApps) {
                 const outcome = {
@@ -103,7 +127,7 @@ export default defineCommand({
                 if (dryRun) {
                     continue;
                 }
-                await importApp(organizationId, outcome);
+                await importApp(organizationId, outcome, gitConnectionIds);
             }
             const errorCount = outcomes.reduce((count, outcome) => count + outcome.errors.length, 0);
             if (json) {
@@ -113,13 +137,15 @@ export default defineCommand({
                 printSummary(outcomes, selectedSkippedApps, dryRun === true, file);
             }
             if (errorCount > 0) {
-                // Set the exit code instead of calling `process.exit` so the `finally` block
-                // still deletes the extracted export, which contains secrets.
                 process.exitCode = 1;
             }
         }
         finally {
-            fs.rmSync(tempDirectory, { recursive: true, force: true });
+            removeTempDirectory();
+            process.off('exit', removeTempDirectory);
+            for (const signal of SIGNALS) {
+                process.off(signal, handleSignal);
+            }
         }
     }),
 });
@@ -191,28 +217,42 @@ const resolveIonicAppTypes = async (apps, ionicAppType) => {
     return { resolvedApps, skippedApps };
 };
 const assignUniqueAppNames = async (apps, organizationId) => {
-    const takenNames = new Set();
+    const takenNames = [];
     const limit = 50;
     let offset = 0;
     while (true) {
         const page = await appsService.findAll({ organizationId, limit, offset });
-        for (const app of page) {
-            takenNames.add(app.name);
-        }
+        takenNames.push(...page.map((app) => app.name));
         if (page.length < limit) {
             break;
         }
         offset += limit;
     }
     for (const app of apps) {
-        app.name = generateUniqueAppName(app.sourceName, takenNames);
-        takenNames.add(app.name);
+        app.name = generateUniqueName(app.sourceName, takenNames);
+        takenNames.push(app.name);
         if (app.name !== app.sourceName) {
-            app.notes.push(`An app with the name \`${app.sourceName}\` already exists in the organization. The app is imported as \`${app.name}\`.`);
+            app.renames.push(`The app \`${app.sourceName}\` was renamed to \`${app.name}\` because its name is already taken in the organization.`);
         }
     }
 };
-const importApp = async (organizationId, outcome) => {
+const getGitProviders = (apps) => new Set(apps.flatMap((app) => (app.repository ? [app.repository.provider] : [])));
+const findGitConnectionIds = async (apps, organizationId) => {
+    const gitConnectionIds = new Map();
+    for (const provider of getGitProviders(apps)) {
+        const [gitConnection] = await gitConnectionsService.findAll({
+            organizationId,
+            provider,
+            restricted: false,
+            limit: 1,
+        });
+        if (gitConnection) {
+            gitConnectionIds.set(provider, gitConnection.id);
+        }
+    }
+    return gitConnectionIds;
+};
+const importApp = async (organizationId, outcome, gitConnectionIds) => {
     const { app } = outcome;
     consola.start(`Importing app \`${app.sourceName}\`...`);
     let appId;
@@ -297,16 +337,16 @@ const importApp = async (organizationId, outcome) => {
             outcome.errors.push(`Failed to create environment \`${environment.name}\`: ${getMessageFromUnknownError(error)}`);
         }
     }
-    let existingChannelNames = new Set();
+    let existingChannelNames = [];
     try {
         const existingChannels = await appChannelsService.findAll({ appId });
-        existingChannelNames = new Set(existingChannels.map((channel) => channel.name));
+        existingChannelNames = existingChannels.map((channel) => channel.name);
     }
     catch {
         // If the lookup fails, channel creation errors are reported individually below.
     }
     for (const channel of app.channels) {
-        if (existingChannelNames.has(channel)) {
+        if (isNameTaken(channel, existingChannelNames)) {
             outcome.created.channels++;
             continue;
         }
@@ -390,18 +430,19 @@ const importApp = async (organizationId, outcome) => {
         }
     }
     if (app.repository) {
-        try {
-            await appsService.linkRepository({
-                appId,
-                ownerSlug: app.repository.ownerSlug,
-                provider: app.repository.provider,
-                repositorySlug: app.repository.repositorySlug,
-                projectSlug: app.repository.projectSlug,
-            });
-            consola.success(`Linked repository \`${app.repository.ownerSlug}/${app.repository.repositorySlug}\`.`);
-        }
-        catch (error) {
-            app.notes.push(`The repository \`${app.repository.ownerSlug}/${app.repository.repositorySlug}\` could not be linked: ${getMessageFromUnknownError(error)} Make sure the git provider is connected in the Capawesome Cloud Console and link the repository manually.`);
+        const gitConnectionId = gitConnectionIds.get(app.repository.provider);
+        const repositoryPath = getGitRepositoryPath(app.repository);
+        if (!gitConnectionId) {
+            app.notes.push(`The repository \`${repositoryPath}\` was not linked because the organization has no \`${app.repository.provider}\` git connection.`);
+        }
+        else {
+            try {
+                await appsService.linkRepository({ appId, gitConnectionId, path: repositoryPath });
+                consola.success(`Linked repository \`${repositoryPath}\`.`);
+            }
+            catch (error) {
+                app.notes.push(`The repository \`${repositoryPath}\` could not be linked: ${getMessageFromUnknownError(error)} Link the repository manually in the Capawesome Cloud Console.`);
+            }
         }
     }
 };
@@ -422,17 +463,20 @@ const printSummary = (outcomes, skippedApps, dryRun, file) => {
         Errors: outcome.errors.length,
     })));
     for (const outcome of outcomes) {
-        if (outcome.app.notes.length === 0 && outcome.errors.length === 0) {
+        if (outcome.app.notes.length === 0 && outcome.app.renames.length === 0 && outcome.errors.length === 0) {
             continue;
         }
         consola.log(`\n${outcome.app.sourceName}:`);
-        for (const note of outcome.app.notes) {
+        for (const note of [...outcome.app.notes, ...outcome.app.renames]) {
             consola.warn(note);
         }
         for (const error of outcome.errors) {
             consola.error(error);
         }
     }
+    if (outcomes.some((outcome) => outcome.app.renames.length > 0)) {
+        consola.info('Some resources were renamed because their names were already taken. Make sure to update any CI/CD workflows or scripts that reference the old names.');
+    }
     for (const outcome of outcomes) {
         if (outcome.id) {
             consola.info(`App URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${outcome.id}`);
@@ -468,6 +512,7 @@ const printJsonSummary = (outcomes, skippedApps, warnings, dryRun) => {
             webUrl: outcome.id ? `${DEFAULT_CONSOLE_BASE_URL}/apps/${outcome.id}` : null,
             created: outcome.created,
             notes: outcome.app.notes,
+            renames: outcome.app.renames,
             errors: outcome.errors,
         })),
         skippedApps: skippedApps.map((app) => ({

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

@@ -152,10 +152,12 @@ describe('apps-import', () => {
                 body.appEnvironmentName === 'Production');
         })
             .reply(201, { id: 'automation-1', name: 'Android Release' })
+            .get(`/v1/organizations/${organizationId}/git-connections`)
+            .query({ provider: 'github', restricted: 'false', limit: 1 })
+            .reply(200, [{ id: 'git-connection-1', provider: 'github' }])
             .put(`/v1/apps/${appId}/repository`, {
-            ownerSlug: 'robingenz',
-            provider: 'github',
-            repositorySlug: 'appflow-export-test',
+            gitConnectionId: 'git-connection-1',
+            path: 'robingenz/appflow-export-test',
         })
             .reply(200, { id: appId });
         await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
@@ -193,7 +195,27 @@ describe('apps-import', () => {
         expect(scope.isDone()).toBe(true);
         const output = getJsonOutput();
         expect(output.apps[0].name).toBe('My App (2)');
-        expect(output.apps[0].notes).toContainEqual(expect.stringContaining('`My App (2)`'));
+        expect(output.apps[0].renames).toContainEqual(expect.stringContaining('`My App (2)`'));
+    });
+    it('should rename the app if the name is already taken in a different case', async () => {
+        await writeExportFile([
+            {
+                folder: 'test-6668c18c',
+                files: { 'app-detail.json': { id: '6668c18c', name: 'test', appType: 'capacitor' } },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [{ id: 'app-1', name: 'Test', type: 'capacitor' }])
+            .post('/v1/apps', { name: 'test (2)', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-789', name: 'test (2)', type: 'capacitor' })
+            .get('/v1/apps/app-789/channels')
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(getJsonOutput().apps[0].name).toBe('test (2)');
     });
     it('should continue with the remaining resources if one fails', async () => {
         await writeExportFile([
@@ -368,6 +390,68 @@ describe('apps-import', () => {
             { sourceId: '22222222', sourceName: 'RN App', reason: expect.stringContaining('react_native') },
         ]);
     });
+    it('should link an Azure DevOps repository using the matching git connection', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: {
+                    'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+                    'repo-association.json': {
+                        gitProvider: 'azure_devops',
+                        cloneUrl: 'https://dev.azure.com/my-org/my-project/_git/my-repo',
+                    },
+                },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [])
+            .get(`/v1/organizations/${organizationId}/git-connections`)
+            .query({ provider: 'azure_devops', restricted: 'false', limit: 1 })
+            .reply(200, [{ id: 'git-connection-1', provider: 'azure_devops' }])
+            .post('/v1/apps', { name: 'My App', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-1', name: 'My App', type: 'capacitor' })
+            .get('/v1/apps/app-1/channels')
+            .reply(200, [])
+            .put('/v1/apps/app-1/repository', { gitConnectionId: 'git-connection-1', path: 'my-org/my-project/my-repo' })
+            .reply(200, { id: 'app-1' });
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(getJsonOutput().apps[0].notes).toEqual([]);
+    });
+    it('should not link repositories if the git provider is not connected', async () => {
+        await writeExportFile([
+            {
+                folder: 'My App-6668c18c',
+                files: {
+                    'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+                    'repo-association.json': {
+                        gitProvider: 'github',
+                        cloneUrl: 'https://github.com/robingenz/appflow-export-test.git',
+                    },
+                },
+            },
+        ]);
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/apps')
+            .query({ organizationId, limit: 50, offset: 0 })
+            .reply(200, [])
+            .get(`/v1/organizations/${organizationId}/git-connections`)
+            .query({ provider: 'github', restricted: 'false', limit: 1 })
+            .reply(200, [])
+            .post('/v1/apps', { name: 'My App', type: 'capacitor' })
+            .query({ organizationId })
+            .reply(201, { id: 'app-1', name: 'My App', type: 'capacitor' })
+            .get('/v1/apps/app-1/channels')
+            .reply(200, []);
+        await importCommand.action({ file: exportFile, organizationId, json: true }, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(vi.mocked(consola).warn).toHaveBeenCalledWith(expect.stringContaining('no `github` git connection'));
+        const output = getJsonOutput();
+        expect(output.apps[0].notes).toContainEqual(expect.stringContaining('was not linked'));
+    });
     it('should error in non-interactive environment if no file is provided', async () => {
         await expect(importCommand.action({ organizationId }, undefined)).rejects.toThrow('Process exited with code 1');
         expect(vi.mocked(consola).error).toHaveBeenCalledWith('You must provide the export file path when running in non-interactive environment.');

package/dist/commands/apps/link.js

@@ -1,7 +1,9 @@
+import { DEFAULT_CONSOLE_BASE_URL } from '../../config/consts.js';
 import appsService from '../../services/apps.js';
+import gitConnectionsService from '../../services/git-connections.js';
 import { withAuth } from '../../utils/auth.js';
 import { isInteractive } from '../../utils/environment.js';
-import { getGitRemoteInfo } from '../../utils/git.js';
+import { getGitRemoteInfo, getGitRepositoryPath } from '../../utils/git.js';
 import { promptAppSelection, promptOrganizationSelection } from '../../utils/prompt.js';
 import consola from 'consola';
 import { z } from 'zod';
@@ -10,9 +12,13 @@ export default defineCommand({
     description: 'Connect a git repository to an app.',
     options: defineOptions(z.object({
         appId: z.string().optional().describe('ID of the app.'),
+        gitConnectionId: z
+            .string()
+            .optional()
+            .describe('ID of the git connection to use. Defaults to the first git connection of the organization for the git provider of the repository.'),
     })),
     action: withAuth(async (options, args) => {
-        let { appId } = options;
+        let { appId, gitConnectionId } = options;
         if (!appId) {
             if (!isInteractive()) {
                 consola.error('You must provide the app ID when running in non-interactive environment.');
@@ -22,12 +28,24 @@ export default defineCommand({
             appId = await promptAppSelection(organizationId);
         }
         const gitRemoteInfo = getGitRemoteInfo();
+        if (!gitConnectionId) {
+            const app = await appsService.findOne({ appId });
+            const [gitConnection] = await gitConnectionsService.findAll({
+                organizationId: app.organizationId,
+                provider: gitRemoteInfo.provider,
+                restricted: false,
+                limit: 1,
+            });
+            if (!gitConnection) {
+                consola.error(`No \`${gitRemoteInfo.provider}\` git connection found in the organization. Connect the git provider first at ${DEFAULT_CONSOLE_BASE_URL}/organizations/${app.organizationId}/git.`);
+                process.exit(1);
+            }
+            gitConnectionId = gitConnection.id;
+        }
         await appsService.linkRepository({
             appId,
-            ownerSlug: gitRemoteInfo.ownerSlug,
-            provider: gitRemoteInfo.provider,
-            repositorySlug: gitRemoteInfo.repositorySlug,
-            projectSlug: gitRemoteInfo.projectSlug,
+            gitConnectionId,
+            path: getGitRepositoryPath(gitRemoteInfo),
         });
         consola.success('Repository connected successfully.');
     }),

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

@@ -13,7 +13,8 @@ vi.mock('consola');
 vi.mock('@/utils/environment.js', () => ({
     isInteractive: () => true,
 }));
-vi.mock('@/utils/git.js', () => ({
+vi.mock('@/utils/git.js', async (importOriginal) => ({
+    ...(await importOriginal()),
     getGitRemoteInfo: () => ({
         ownerSlug: 'capawesome-team',
         provider: 'github',
@@ -26,10 +27,13 @@ describe('apps-link', () => {
     const mockPromptAppSelection = vi.mocked(promptAppSelection);
     const mockConsola = vi.mocked(consola);
     const mockAuthorizationService = vi.mocked(authorizationService);
+    const appId = 'app-123';
+    const organizationId = 'org-1';
+    const testToken = 'test-token';
     beforeEach(() => {
         vi.clearAllMocks();
-        mockUserConfig.read.mockReturnValue({ token: 'test-token' });
-        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('test-token');
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(testToken);
         mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
         vi.spyOn(process, 'exit').mockImplementation((code) => {
             throw new Error(`Process exited with code ${code}`);
@@ -39,56 +43,50 @@ describe('apps-link', () => {
         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',
-        })
+    const mockGitConnectionLookup = (gitConnections) => nock(DEFAULT_API_BASE_URL)
+        .get(`/v1/apps/${appId}`)
+        .reply(200, { id: appId, name: 'Test App', organizationId, type: 'capacitor' })
+        .get(`/v1/organizations/${organizationId}/git-connections`)
+        .query({ provider: 'github', restricted: 'false', limit: 1 })
+        .reply(200, gitConnections);
+    it('should link repository using the git connection of the organization', async () => {
+        const scope = mockGitConnectionLookup([{ id: 'git-connection-1' }])
+            .put(`/v1/apps/${appId}/repository`, { gitConnectionId: 'git-connection-1', path: 'capawesome-team/cli' })
             .matchHeader('Authorization', `Bearer ${testToken}`)
             .reply(200, { id: appId, name: 'Test App' });
-        await linkCommand.action(options, undefined);
+        await linkCommand.action({ appId }, undefined);
         expect(scope.isDone()).toBe(true);
         expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
     });
+    it('should link repository using the provided git connection ID', async () => {
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .put(`/v1/apps/${appId}/repository`, { gitConnectionId: 'git-connection-2', path: 'capawesome-team/cli' })
+            .reply(200, { id: appId, name: 'Test App' });
+        await linkCommand.action({ appId, gitConnectionId: 'git-connection-2' }, undefined);
+        expect(scope.isDone()).toBe(true);
+    });
     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);
+        mockPromptOrganizationSelection.mockResolvedValueOnce(organizationId);
         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}`)
+        const scope = mockGitConnectionLookup([{ id: 'git-connection-1' }])
+            .put(`/v1/apps/${appId}/repository`, { gitConnectionId: 'git-connection-1', path: 'capawesome-team/cli' })
             .reply(200, { id: appId, name: 'Test App' });
-        await linkCommand.action(options, undefined);
+        await linkCommand.action({}, undefined);
         expect(scope.isDone()).toBe(true);
         expect(mockPromptOrganizationSelection).toHaveBeenCalled();
-        expect(mockPromptAppSelection).toHaveBeenCalledWith(orgId);
-        expect(mockConsola.success).toHaveBeenCalledWith('Repository connected successfully.');
+        expect(mockPromptAppSelection).toHaveBeenCalledWith(organizationId);
+    });
+    it('should error if the organization has no git connection for the provider', async () => {
+        const scope = mockGitConnectionLookup([]);
+        await expect(linkCommand.action({ appId }, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith(expect.stringContaining('No `github` git connection found'));
     });
     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();
+        const scope = mockGitConnectionLookup([{ id: 'git-connection-1' }])
+            .put(`/v1/apps/${appId}/repository`, { gitConnectionId: 'git-connection-1', path: 'capawesome-team/cli' })
+            .reply(400, { message: 'Repository not found' });
+        await expect(linkCommand.action({ appId }, undefined)).rejects.toThrow();
         expect(scope.isDone()).toBe(true);
     });
 });

package/dist/services/git-connections.js

@@ -0,0 +1,32 @@
+import authorizationService from '../services/authorization-service.js';
+import httpClient from '../utils/http-client.js';
+class GitConnectionsServiceImpl {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async findAll(dto) {
+        const params = {};
+        if (dto.limit !== undefined) {
+            params.limit = dto.limit.toString();
+        }
+        if (dto.offset !== undefined) {
+            params.offset = dto.offset.toString();
+        }
+        if (dto.provider !== undefined) {
+            params.provider = dto.provider;
+        }
+        if (dto.restricted !== undefined) {
+            params.restricted = dto.restricted.toString();
+        }
+        const response = await this.httpClient.get(`/v1/organizations/${dto.organizationId}/git-connections`, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+            params,
+        });
+        return response.data;
+    }
+}
+const gitConnectionsService = new GitConnectionsServiceImpl(httpClient);
+export default gitConnectionsService;

package/dist/types/git-connection.js

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

package/dist/utils/app-import.js

@@ -1,10 +1,11 @@
-export const generateUniqueAppName = (name, takenNames) => {
-    if (!takenNames.has(name)) {
-        return name;
-    }
+// Capawesome Cloud enforces name uniqueness on the lowercased name.
+export const isNameTaken = (name, takenNames) => takenNames.some((takenName) => takenName.toLowerCase() === name.toLowerCase());
+export const generateUniqueName = (name, takenNames) => {
+    let uniqueName = name;
     let counter = 2;
-    while (takenNames.has(`${name} (${counter})`)) {
+    while (isNameTaken(uniqueName, takenNames)) {
+        uniqueName = `${name} (${counter})`;
         counter++;
     }
-    return `${name} (${counter})`;
+    return uniqueName;
 };

package/dist/utils/app-import.test.js

@@ -0,0 +1,20 @@
+import { generateUniqueName, isNameTaken } from '../utils/app-import.js';
+import { describe, expect, it } from 'vitest';
+describe('isNameTaken', () => {
+    it('should match names regardless of case', () => {
+        expect(isNameTaken('test', ['Test'])).toBe(true);
+        expect(isNameTaken('TEST', ['Test'])).toBe(true);
+        expect(isNameTaken('other', ['Test'])).toBe(false);
+    });
+});
+describe('generateUniqueName', () => {
+    it('should keep a name that is not taken', () => {
+        expect(generateUniqueName('Production', [])).toBe('Production');
+    });
+    it('should suffix a name that is taken regardless of case', () => {
+        expect(generateUniqueName('Production', ['production'])).toBe('Production (2)');
+    });
+    it('should skip suffixes that are taken', () => {
+        expect(generateUniqueName('Prod', ['prod', 'Prod (2)'])).toBe('Prod (3)');
+    });
+});

package/dist/utils/appflow-export.js

@@ -1,3 +1,4 @@
+import { generateUniqueName, } from '../utils/app-import.js';
 import { getMessageFromUnknownError, UserError } from '../utils/error.js';
 import { parseGitRemoteUrl } from '../utils/git.js';
 import fs from 'fs';
@@ -160,11 +161,21 @@ const mapAppType = (appType) => {
 };
 const parseApp = (appFolder, detail, type) => {
     const notes = [];
-    const environments = parseJsonFileIfExists(path.join(appFolder, 'environments.json'), environmentsSchema) ?? [];
-    const channels = parseJsonFileIfExists(path.join(appFolder, 'live-update-channels.json'), liveUpdateChannelsSchema) ?? [];
-    const nativeConfigs = parseJsonFileIfExists(path.join(appFolder, 'native-configs.json'), nativeConfigsSchema) ?? [];
-    const certificates = parseCertificates(appFolder, notes);
-    const destinations = parseDestinations(appFolder);
+    const renames = [];
+    // Duplicates are renamed before the id-to-name maps are built so that
+    // automations reference the renamed resources.
+    const environments = renameDuplicates(parseJsonFileIfExists(path.join(appFolder, 'environments.json'), environmentsSchema) ?? [], 'environment', renames);
+    const channels = renameDuplicates(parseJsonFileIfExists(path.join(appFolder, 'live-update-channels.json'), liveUpdateChannelsSchema) ?? [], 'channel', renames);
+    const nativeConfigs = renameDuplicates(parseJsonFileIfExists(path.join(appFolder, 'native-configs.json'), nativeConfigsSchema) ?? [], 'configuration', renames);
+    const certificates = renameDuplicates(parseCertificates(appFolder, notes), 'certificate', renames);
+    const destinations = renameDuplicates(parseDestinations(appFolder), 'destination', renames);
+    const automations = renameDuplicates(parseAutomations(appFolder, {
+        certificateNamesById: toNameMap(certificates),
+        channelNamesById: new Map(channels.map((channel) => [channel.id, channel.name])),
+        configurationNamesById: toNameMap(nativeConfigs),
+        destinationNamesById: toNameMap(destinations),
+        environmentNamesById: toNameMap(environments),
+    }, notes), 'automation', renames);
     return {
         sourceId: detail.id,
         sourceName: detail.name,
@@ -173,17 +184,12 @@ const parseApp = (appFolder, detail, type) => {
         type,
         latestBuildNumber: detail.latestBuildNumber ?? undefined,
         notes,
-        automations: parseAutomations(appFolder, {
-            certificateNamesById: toNameMap(certificates.map((certificate) => ({ id: certificate.id, name: certificate.certificate.name }))),
-            channelNamesById: new Map(channels.map((channel) => [channel.id, channel.name])),
-            configurationNamesById: toNameMap(nativeConfigs),
-            destinationNamesById: toNameMap(destinations.map((destination) => ({ id: destination.id, name: destination.destination.name }))),
-            environmentNamesById: toNameMap(environments),
-        }, notes),
-        certificates: certificates.map((certificate) => certificate.certificate),
+        renames,
+        automations,
+        certificates: certificates.map(({ id, ...certificate }) => certificate),
         channels: channels.map((channel) => channel.name),
         configurations: parseConfigurations(nativeConfigs, notes),
-        destinations: destinations.map((destination) => destination.destination),
+        destinations: destinations.map(({ id, ...destination }) => destination),
         environments: environments.map((environment) => ({
             name: environment.name,
             variables: Object.entries(environment.vars ?? {}).map(([key, value]) => ({ key, value })),
@@ -201,10 +207,13 @@ const parseRepository = (appFolder, notes) => {
         return parseGitRemoteUrl(repoAssociation.cloneUrl);
     }
     catch {
-        notes.push(`The git repository \`${repoAssociation.cloneUrl}\` (provider \`${repoAssociation.gitProvider}\`) is not supported and was not linked. You can link a repository manually in the Capawesome Cloud Console.`);
+        notes.push(`The git repository \`${stripCredentials(repoAssociation.cloneUrl)}\` (provider \`${repoAssociation.gitProvider}\`) is not supported and was not linked. You can link a repository manually in the Capawesome Cloud Console.`);
         return null;
     }
 };
+// Removes `user:password@` from URLs as well as from scp-like locations
+// such as `user@host:owner/repo.git`, including malformed ones.
+const stripCredentials = (url) => url.replace(/^([a-z+]+:\/\/)?[^/@]*@/i, '$1');
 const parseConfigurations = (nativeConfigs, notes) => {
     const configurationsWithLiveUpdateSettings = nativeConfigs.filter((config) => config.configs?.ionic);
     if (configurationsWithLiveUpdateSettings.length > 0) {
@@ -231,15 +240,13 @@ const parseCertificates = (appFolder, notes) => {
         }
         certificates.push({
             id: metadata.id,
-            certificate: {
-                name: metadata.name,
-                platform: 'android',
-                filePath,
-                password: metadata.keystorePassword,
-                keyAlias: metadata.keyAlias,
-                keyPassword: metadata.keyPassword,
-                provisioningProfilePaths: [],
-            },
+            name: metadata.name,
+            platform: 'android',
+            filePath,
+            password: metadata.keystorePassword,
+            keyAlias: metadata.keyAlias,
+            keyPassword: metadata.keyPassword,
+            provisioningProfilePaths: [],
         });
     }
     for (const folder of getSubfolders(path.join(appFolder, 'signing-certificates', 'ios'))) {
@@ -268,13 +275,11 @@ const parseCertificates = (appFolder, notes) => {
         }
         certificates.push({
             id: metadata.id,
-            certificate: {
-                name: metadata.name,
-                platform: 'ios',
-                filePath,
-                password: metadata.p12Password,
-                provisioningProfilePaths,
-            },
+            name: metadata.name,
+            platform: 'ios',
+            filePath,
+            password: metadata.p12Password,
+            provisioningProfilePaths,
         });
     }
     return certificates;
@@ -286,33 +291,27 @@ const parseDestinations = (appFolder) => {
         const googleServiceAccountKeyPath = path.join(folder, 'json-key.json');
         destinations.push({
             id: metadata.id,
-            destination: {
-                name: metadata.name,
-                platform: 'android',
-                androidPackageName: metadata.packageName ?? undefined,
-                androidBuildArtifactType: metadata.artifactType === 'aab' || metadata.artifactType === 'apk' ? metadata.artifactType : undefined,
-                androidReleaseStatus: metadata.releaseStatus === 'completed' || metadata.releaseStatus === 'draft'
-                    ? metadata.releaseStatus
-                    : undefined,
-                googlePlayTrack: metadata.track ?? undefined,
-                googleServiceAccountKeyPath: fs.existsSync(googleServiceAccountKeyPath)
-                    ? googleServiceAccountKeyPath
-                    : undefined,
-            },
+            name: metadata.name,
+            platform: 'android',
+            androidPackageName: metadata.packageName ?? undefined,
+            androidBuildArtifactType: metadata.artifactType === 'aab' || metadata.artifactType === 'apk' ? metadata.artifactType : undefined,
+            androidReleaseStatus: metadata.releaseStatus === 'completed' || metadata.releaseStatus === 'draft'
+                ? metadata.releaseStatus
+                : undefined,
+            googlePlayTrack: metadata.track ?? undefined,
+            googleServiceAccountKeyPath: fs.existsSync(googleServiceAccountKeyPath) ? googleServiceAccountKeyPath : undefined,
         });
     }
     for (const folder of getSubfolders(path.join(appFolder, 'store-destinations', 'ios'))) {
         const metadata = parseJsonFile(path.join(folder, 'app-store-destination.json'), appStoreDestinationSchema);
         destinations.push({
             id: metadata.id,
-            destination: {
-                name: metadata.name,
-                platform: 'ios',
-                appleId: metadata.appleId ?? undefined,
-                appleAppId: metadata.appAppleId ?? undefined,
-                appleTeamId: metadata.teamId ?? undefined,
-                appleAppPassword: metadata.appPassword ?? undefined,
-            },
+            name: metadata.name,
+            platform: 'ios',
+            appleId: metadata.appleId ?? undefined,
+            appleAppId: metadata.appAppleId ?? undefined,
+            appleTeamId: metadata.teamId ?? undefined,
+            appleAppPassword: metadata.appPassword ?? undefined,
         });
     }
     return destinations;
@@ -388,6 +387,17 @@ const resolveName = (namesById, id, automationName, label, notes) => {
 const toNameMap = (entities) => {
     return new Map(entities.map((entity) => [entity.id, entity.name]));
 };
+const renameDuplicates = (items, label, renames) => {
+    const takenNames = [];
+    return items.map((item) => {
+        const name = generateUniqueName(item.name, takenNames);
+        takenNames.push(name);
+        if (name !== item.name) {
+            renames.push(`The ${label} \`${item.name}\` was renamed to \`${name}\` because its name is already taken.`);
+        }
+        return { ...item, name };
+    });
+};
 // Guards against path traversal: the file names come from the export's JSON and
 // must never resolve outside the folder they were extracted to.
 const resolvePathWithinFolder = (folder, fileName) => {

package/dist/utils/appflow-export.test.js

@@ -328,6 +328,66 @@ describe('appflow-export', () => {
         expect(app.notes).toContainEqual(expect.stringContaining('`/etc/hosts` is invalid'));
         expect(app.notes).toContainEqual(expect.stringContaining('`../../../../etc/hosts`'));
     });
+    it('should rename resources whose names only differ in case', async () => {
+        writeAppFiles('Dupes-88888888', {
+            'app-detail.json': { id: '88888888', name: 'Dupes', appType: 'capacitor' },
+            'environments.json': [
+                { id: 1, name: 'Staging', vars: {}, secrets: null },
+                { id: 2, name: 'staging', vars: {}, secrets: null },
+            ],
+            'native-build-automations.json': [
+                {
+                    name: 'Android Release',
+                    gitBranch: 'main',
+                    platform: 'android',
+                    buildType: 'release',
+                    environmentId: 2,
+                    webhook: null,
+                    automationEnabled: true,
+                    nativeConfigId: null,
+                    signingCertificateId: null,
+                    destinationId: 27892,
+                },
+            ],
+            'store-destinations/android/Prod-27890/play-store-destination.json': {
+                id: 27890,
+                name: 'Prod',
+                artifactType: 'aab',
+                packageName: 'dev.example.app',
+                track: 'internal',
+            },
+            'store-destinations/android/prod-27892/play-store-destination.json': {
+                id: 27892,
+                name: 'prod',
+                artifactType: 'aab',
+                packageName: 'dev.example.app',
+                track: 'production',
+            },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        const app = apps[0];
+        expect(app.environments.map((environment) => environment.name)).toEqual(['Staging', 'staging (2)']);
+        expect(app.destinations.map((destination) => destination.name)).toEqual(['Prod', 'prod (2)']);
+        expect(app.automations[0]).toMatchObject({ appEnvironmentName: 'staging (2)', appDestinationName: 'prod (2)' });
+        expect(app.renames).toEqual([
+            'The environment `staging` was renamed to `staging (2)` because its name is already taken.',
+            'The destination `prod` was renamed to `prod (2)` because its name is already taken.',
+        ]);
+    });
+    it.each([
+        ['https://user:secret-token@git.example.com/owner/repo.git', 'https://git.example.com/owner/repo.git'],
+        ['https://user:secret-token@', 'https://'],
+        ['user:secret-token@git.example.com:owner/repo.git', 'git.example.com:owner/repo.git'],
+    ])('should not echo credentials of the unsupported repository url %s', async (cloneUrl, sanitizedUrl) => {
+        writeAppFiles('Private Repo-99999999', {
+            'app-detail.json': { id: '99999999', name: 'Private Repo', appType: 'capacitor' },
+            'repo-association.json': { gitProvider: 'gitlab_enterprise', cloneUrl },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].repository).toBeNull();
+        expect(apps[0].notes).toContainEqual(expect.stringContaining(`\`${sanitizedUrl}\``));
+        expect(JSON.stringify(apps[0].notes)).not.toContain('secret-token');
+    });
     it('should skip an app with an invalid app detail file', async () => {
         writeAppFiles('Invalid-66666666', {
             'app-detail.json': 'not json',

package/dist/utils/git.js

@@ -4,8 +4,8 @@ const HOSTNAME_TO_PROVIDER = {
     'github.com': 'github',
     'gitlab.com': 'gitlab',
     'bitbucket.org': 'bitbucket',
-    'dev.azure.com': 'azure',
-    'ssh.dev.azure.com': 'azure',
+    'dev.azure.com': 'azure_devops',
+    'ssh.dev.azure.com': 'azure_devops',
 };
 export const getGitRemoteInfo = () => {
     const remoteUrl = getGitRemoteUrl();
@@ -25,7 +25,7 @@ export const parseGitRemoteUrl = (remoteUrl) => {
     if (azureHttpsMatch && azureHttpsMatch[1] && azureHttpsMatch[2] && azureHttpsMatch[3]) {
         return {
             ownerSlug: azureHttpsMatch[1],
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: azureHttpsMatch[3],
             projectSlug: azureHttpsMatch[2],
         };
@@ -35,7 +35,7 @@ export const parseGitRemoteUrl = (remoteUrl) => {
     if (azureSshMatch && azureSshMatch[1] && azureSshMatch[2] && azureSshMatch[3]) {
         return {
             ownerSlug: azureSshMatch[1],
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: azureSshMatch[3],
             projectSlug: azureSshMatch[2],
         };
@@ -45,7 +45,7 @@ export const parseGitRemoteUrl = (remoteUrl) => {
     if (vsHttpsMatch && vsHttpsMatch[1] && vsHttpsMatch[2] && vsHttpsMatch[3]) {
         return {
             ownerSlug: vsHttpsMatch[1],
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: vsHttpsMatch[3],
             projectSlug: vsHttpsMatch[2],
         };
@@ -90,3 +90,4 @@ export const parseGitRemoteUrl = (remoteUrl) => {
     }
     throw new UserError('Could not parse git remote URL.');
 };
+export const getGitRepositoryPath = (remoteInfo) => [remoteInfo.ownerSlug, remoteInfo.projectSlug, remoteInfo.repositorySlug].filter(Boolean).join('/');

package/dist/utils/git.test.js

@@ -87,7 +87,7 @@ describe('parseGitRemoteUrl', () => {
         const result = parseGitRemoteUrl('https://dev.azure.com/my-org/my-project/_git/my-repo');
         expect(result).toEqual({
             ownerSlug: 'my-org',
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: 'my-repo',
             projectSlug: 'my-project',
         });
@@ -96,7 +96,7 @@ describe('parseGitRemoteUrl', () => {
         const result = parseGitRemoteUrl('git@ssh.dev.azure.com:v3/my-org/my-project/my-repo');
         expect(result).toEqual({
             ownerSlug: 'my-org',
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: 'my-repo',
             projectSlug: 'my-project',
         });
@@ -105,7 +105,7 @@ describe('parseGitRemoteUrl', () => {
         const result = parseGitRemoteUrl('https://my-org.visualstudio.com/my-project/_git/my-repo');
         expect(result).toEqual({
             ownerSlug: 'my-org',
-            provider: 'azure',
+            provider: 'azure_devops',
             repositorySlug: 'my-repo',
             projectSlug: 'my-project',
         });

package/dist/utils/http-client.js

@@ -2,19 +2,28 @@ import { createRequire } from 'module';
 import configService from '../services/config.js';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
+import consola from 'consola';
 import { HttpProxyAgent } from 'http-proxy-agent';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
+const isRateLimitError = (error) => error.response?.status === 429;
 // Register middleware to retry failed requests
 axiosRetry(axios, {
     retries: 3,
+    // Waits at least as long as the `Retry-After` header of rate limited responses
     retryDelay: axiosRetry.exponentialDelay,
     retryCondition: (error) => {
-        // Network errors and 5xx responses are retried
+        // Network errors, rate limited requests and 5xx responses are retried
         return (axiosRetry.isNetworkOrIdempotentRequestError(error) ||
+            isRateLimitError(error) ||
             (error.response?.status !== undefined && error.response.status >= 500));
     },
+    onRetry: (_retryCount, error) => {
+        if (isRateLimitError(error)) {
+            consola.warn('Rate limit reached. Retrying...');
+        }
+    },
 });
 /**
  * Gets the appropriate proxy agent based on the target URL protocol and environment variables.

package/dist/utils/http-client.test.js

@@ -1,4 +1,5 @@
 import configService from '../services/config.js';
+import consola from 'consola';
 import nock from 'nock';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 // Mock the config service
@@ -7,6 +8,7 @@ vi.mock('@/services/config.js', () => ({
         getValueForKey: vi.fn().mockResolvedValue('https://api.example.com'),
     },
 }));
+vi.mock('consola');
 describe('http-client', () => {
     let originalEnv;
     beforeEach(() => {
@@ -23,6 +25,7 @@ describe('http-client', () => {
     afterEach(() => {
         // Restore original environment variables
         process.env = originalEnv;
+        vi.useRealTimers();
     });
     it('should retry requests on 5xx status codes', async () => {
         // Mock the API_BASE_URL
@@ -50,6 +53,29 @@ describe('http-client', () => {
         await expect(httpClient.get('/not-found')).rejects.toThrow();
         expect(nock.isDone()).toBe(true);
     });
+    it('should retry rate limited requests after the `Retry-After` delay', async () => {
+        vi.mocked(configService.getValueForKey).mockResolvedValue('https://api.example.com');
+        // Mock a 429 response followed by success
+        nock('https://api.example.com')
+            .post('/rate-limited')
+            .reply(429, { error: 'Too Many Requests' }, { 'Retry-After': '10' })
+            .post('/rate-limited')
+            .reply(200, { success: true });
+        const { default: httpClient } = await import('./http-client.js');
+        // Only fake `setTimeout` so the request itself is still served by nock
+        vi.useFakeTimers({ toFake: ['setTimeout'] });
+        const responsePromise = httpClient.post('/rate-limited');
+        // Wait until the retry has been scheduled
+        await vi.waitFor(() => expect(vi.getTimerCount()).toBe(1));
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(nock.isDone()).toBe(false);
+        await vi.runAllTimersAsync();
+        const response = await responsePromise;
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual({ success: true });
+        expect(nock.isDone()).toBe(true);
+        expect(consola.warn).toHaveBeenCalledWith('Rate limit reached. Retrying...');
+    });
     it('should eventually fail after maximum retries on persistent 5xx errors', async () => {
         vi.mocked(configService.getValueForKey).mockResolvedValue('https://api.example.com');
         // Mock 4 consecutive 500 responses (initial + 3 retries)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "4.19.0",
+  "version": "4.21.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {