@capawesome/cli 3.10.2 → 3.11.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.
 
+## [3.11.0](https://github.com/capawesome-team/cli/compare/v3.10.2...v3.11.0) (2026-01-08)
+
+
+### Features
+
+* **apps:** add commands for managing environments ([#109](https://github.com/capawesome-team/cli/issues/109)) ([2d548f3](https://github.com/capawesome-team/cli/commit/2d548f380e536e94a38b6908dadb31566eac449e))
+
 ## [3.10.2](https://github.com/capawesome-team/cli/compare/v3.10.1...v3.10.2) (2025-12-30)
 
 ## [3.10.1](https://github.com/capawesome-team/cli/compare/v3.10.0...v3.10.1) (2025-12-29)

package/dist/commands/apps/channels/delete.js

@@ -64,9 +64,17 @@ export default defineCommand({
                 consola.error('You must provide either the channel ID or name when running in non-interactive environment.');
                 process.exit(1);
             }
-            name = await prompt('Enter the channel name:', {
-                type: 'text',
+            const channels = await appChannelsService.findAll({ appId });
+            if (!channels.length) {
+                consola.error('No channels found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectedChannelId = await prompt('Select the channel to delete:', {
+                type: 'select',
+                options: channels.map((channel) => ({ label: channel.name, value: channel.id })),
             });
+            channelId = selectedChannelId;
         }
         // Confirm deletion
         if (isInteractive()) {

package/dist/commands/apps/channels/delete.test.js

@@ -107,22 +107,37 @@ describe('apps-channels-delete', () => {
         expect(deleteScope.isDone()).toBe(true);
         expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
     });
-    it('should prompt for channel name when neither channelId nor name provided', async () => {
+    it('should prompt for channel selection when channelId and name not provided', async () => {
         const appId = 'app-123';
+        const channelId = 'channel-456';
         const channelName = 'development';
         const testToken = 'test-token';
         const options = { appId };
-        const scope = nock(DEFAULT_API_BASE_URL)
-            .delete(`/v1/apps/${appId}/channels`)
-            .query({ name: channelName })
+        const channelsListScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/channels`)
+            .query(true)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, [
+            {
+                id: channelId,
+                name: channelName,
+                appId,
+            },
+        ]);
+        const deleteScope = nock(DEFAULT_API_BASE_URL)
+            .delete(`/v1/apps/${appId}/channels/${channelId}`)
             .matchHeader('Authorization', `Bearer ${testToken}`)
             .reply(200);
         mockPrompt
-            .mockResolvedValueOnce(channelName) // channel name input
+            .mockResolvedValueOnce(channelId) // channel selection
             .mockResolvedValueOnce(true); // confirmation
         await deleteChannelCommand.action(options, undefined);
-        expect(scope.isDone()).toBe(true);
-        expect(mockPrompt).toHaveBeenCalledWith('Enter the channel name:', { type: 'text' });
+        expect(channelsListScope.isDone()).toBe(true);
+        expect(deleteScope.isDone()).toBe(true);
+        expect(mockPrompt).toHaveBeenCalledWith('Select the channel to delete:', {
+            type: 'select',
+            options: [{ label: channelName, value: channelId }],
+        });
         expect(mockConsola.success).toHaveBeenCalledWith('Channel deleted successfully.');
     });
     it('should handle API error during deletion', async () => {

package/dist/commands/apps/channels/list.js

@@ -1,5 +1,9 @@
 import appChannelsService from '../../../services/app-channels.js';
+import appsService from '../../../services/apps.js';
 import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
 import { defineCommand, defineOptions } from '@robingenz/zli';
 import consola from 'consola';
 import { z } from 'zod';
@@ -18,8 +22,36 @@ export default defineCommand({
             process.exit(1);
         }
         if (!appId) {
-            consola.error('You must provide an app ID.');
-            process.exit(1);
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before listing channels.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to list channels.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to list channels.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before listing channels.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to list the channels for?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
         }
         const foundChannels = await appChannelsService.findAll({
             appId,

package/dist/commands/apps/channels/list.test.js

@@ -38,7 +38,7 @@ describe('apps-channels-list', () => {
     it('should require appId', async () => {
         const options = { appId: undefined };
         await expect(listChannelsCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
-        expect(mockConsola.error).toHaveBeenCalledWith('You must provide an app ID.');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide an app ID when running in non-interactive environment.');
     });
     it('should list channels and display table format', async () => {
         const appId = 'app-123';

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

@@ -0,0 +1,68 @@
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new environment.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        name: z.string().optional().describe('Name of the environment.'),
+    })),
+    action: async (options, args) => {
+        let { appId, name } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before creating an environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to create an environment.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to create an environment.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before creating an environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to create the environment for?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+        }
+        if (!name) {
+            if (!isInteractive()) {
+                consola.error('You must provide the environment name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            name = await prompt('Enter the name of the environment:', { type: 'text' });
+        }
+        const response = await appEnvironmentsService.create({
+            appId,
+            name,
+        });
+        consola.success('Environment created successfully.');
+        consola.info(`Environment ID: ${response.id}`);
+    },
+});

package/dist/commands/apps/environments/delete.js

@@ -0,0 +1,87 @@
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Delete an environment.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        environmentId: z.string().optional().describe('ID of the environment. Either the ID or name must be provided.'),
+        name: z.string().optional().describe('Name of the environment. Either the ID or name must be provided.'),
+    })),
+    action: async (options, args) => {
+        let { appId, environmentId, name } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before deleting an environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app from which you want to delete an environment.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app from which you want to delete an environment.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before deleting an environment.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to delete the environment from?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+        }
+        if (!environmentId && !name) {
+            if (!isInteractive()) {
+                consola.error('You must provide either the environment ID or name when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const environments = await appEnvironmentsService.findAll({ appId });
+            if (!environments.length) {
+                consola.error('No environments found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const selectedEnvironmentId = await prompt('Select the environment to delete:', {
+                type: 'select',
+                options: environments.map((env) => ({ label: env.name, value: env.id })),
+            });
+            environmentId = selectedEnvironmentId;
+        }
+        if (isInteractive()) {
+            const confirmed = await prompt('Are you sure you want to delete this environment?', {
+                type: 'confirm',
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        await appEnvironmentsService.delete({
+            appId,
+            id: environmentId,
+            name,
+        });
+        consola.success('Environment deleted successfully.');
+    },
+});

package/dist/commands/apps/environments/list.js

@@ -0,0 +1,69 @@
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'List all environments for an app.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+        limit: z.coerce.number().optional().describe('Limit for pagination.'),
+        offset: z.coerce.number().optional().describe('Offset for pagination.'),
+    })),
+    action: async (options, args) => {
+        let { appId, json, limit, offset } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before listing environments.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to list environments.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to list environments.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before listing environments.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to list the environments for?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+        }
+        const environments = await appEnvironmentsService.findAll({
+            appId,
+            limit,
+            offset,
+        });
+        if (json) {
+            console.log(JSON.stringify(environments, null, 2));
+        }
+        else {
+            console.table(environments);
+            consola.success('Environments retrieved successfully.');
+        }
+    },
+});

package/dist/commands/apps/environments/set.js

@@ -0,0 +1,126 @@
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { parseKeyValuePairs } from '../../../utils/app-environments.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import fs from 'fs';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Set environment variables and secrets.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        environmentId: z.string().optional().describe('ID of the environment.'),
+        variable: z
+            .array(z.string())
+            .optional()
+            .describe('Environment variable in key=value format. Can be specified multiple times.'),
+        variableFile: z.string().optional().describe('Path to a file containing environment variables in .env format.'),
+        secret: z
+            .array(z.string())
+            .optional()
+            .describe('Environment secret in key=value format. Can be specified multiple times.'),
+        secretFile: z.string().optional().describe('Path to a file containing environment secrets in .env format.'),
+    })),
+    action: async (options, args) => {
+        let { appId, environmentId, variable, variableFile, secret, secretFile } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before setting environment variables or secrets.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to set environment variables or secrets.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to set environment variables or secrets.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before setting environment variables or secrets.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to set the environment variables or secrets for?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+        }
+        if (!environmentId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an environment ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const environments = await appEnvironmentsService.findAll({ appId });
+            if (!environments.length) {
+                consola.error('No environments found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            environmentId = await prompt('Select the environment:', {
+                type: 'select',
+                options: environments.map((env) => ({ label: env.name, value: env.id })),
+            });
+        }
+        // Parse variables from inline and file
+        const variablesMap = new Map();
+        if (variableFile) {
+            const fileContent = await fs.promises.readFile(variableFile, 'utf-8');
+            const fileVariables = parseKeyValuePairs(fileContent);
+            fileVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        if (variable) {
+            const inlineVariables = parseKeyValuePairs(variable.join('\n'));
+            inlineVariables.forEach((v) => variablesMap.set(v.key, v.value));
+        }
+        const allVariables = Array.from(variablesMap.entries()).map(([key, value]) => ({ key, value }));
+        // Parse secrets from inline and file
+        const secretsMap = new Map();
+        if (secretFile) {
+            const fileContent = await fs.promises.readFile(secretFile, 'utf-8');
+            const fileSecrets = parseKeyValuePairs(fileContent);
+            fileSecrets.forEach((s) => secretsMap.set(s.key, s.value));
+        }
+        if (secret) {
+            const inlineSecrets = parseKeyValuePairs(secret.join('\n'));
+            inlineSecrets.forEach((s) => secretsMap.set(s.key, s.value));
+        }
+        const allSecrets = Array.from(secretsMap.entries()).map(([key, value]) => ({ key, value }));
+        if (!allVariables.length && !allSecrets.length) {
+            consola.error('You must provide at least one variable or secret to set.');
+            process.exit(1);
+        }
+        if (allVariables.length) {
+            await appEnvironmentsService.setVariables({
+                appId,
+                environmentId,
+                variables: allVariables,
+            });
+        }
+        if (allSecrets.length) {
+            await appEnvironmentsService.setSecrets({
+                appId,
+                environmentId,
+                secrets: allSecrets,
+            });
+        }
+        consola.success('Environment variables and secrets set successfully.');
+    },
+});

package/dist/commands/apps/environments/unset.js

@@ -0,0 +1,98 @@
+import appEnvironmentsService from '../../../services/app-environments.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Unset environment variables and secrets.',
+    options: defineOptions(z.object({
+        appId: z.string().optional().describe('ID of the app.'),
+        environmentId: z.string().optional().describe('ID of the environment.'),
+        variable: z
+            .array(z.string())
+            .optional()
+            .describe('Key of the environment variable to unset. Can be specified multiple times.'),
+        secret: z
+            .array(z.string())
+            .optional()
+            .describe('Key of the environment secret to unset. Can be specified multiple times.'),
+    })),
+    action: async (options, args) => {
+        let { appId, environmentId, variable: variableKeys, secret: secretKeys } = options;
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command. Please run the `login` command first.');
+            process.exit(1);
+        }
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before unsetting environment variables or secrets.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to unset environment variables or secrets.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to unset environment variables or secrets.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
+            if (!apps.length) {
+                consola.error('You must create an app before unsetting environment variables or secrets.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            appId = await prompt('Which app do you want to unset the environment variables or secrets for?', {
+                type: 'select',
+                options: apps.map((app) => ({ label: app.name, value: app.id })),
+            });
+        }
+        if (!environmentId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an environment ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const environments = await appEnvironmentsService.findAll({ appId });
+            if (!environments.length) {
+                consola.error('No environments found for this app. Create one first.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            environmentId = await prompt('Select the environment:', {
+                type: 'select',
+                options: environments.map((env) => ({ label: env.name, value: env.id })),
+            });
+        }
+        if (!variableKeys?.length && !secretKeys?.length) {
+            consola.error('You must provide at least one variable key or secret key to unset.');
+            process.exit(1);
+        }
+        if (variableKeys?.length) {
+            await appEnvironmentsService.unsetVariables({
+                appId,
+                environmentId,
+                keys: variableKeys,
+            });
+        }
+        if (secretKeys?.length) {
+            await appEnvironmentsService.unsetSecrets({
+                appId,
+                environmentId,
+                keys: secretKeys,
+            });
+        }
+        consola.success('Environment variables and secrets unset successfully.');
+    },
+});

package/dist/index.js

@@ -35,6 +35,11 @@ const config = defineConfig({
         'apps:channels:get': await import('./commands/apps/channels/get.js').then((mod) => mod.default),
         'apps:channels:list': await import('./commands/apps/channels/list.js').then((mod) => mod.default),
         'apps:channels:update': await import('./commands/apps/channels/update.js').then((mod) => mod.default),
+        'apps:environments:create': await import('./commands/apps/environments/create.js').then((mod) => mod.default),
+        'apps:environments:delete': await import('./commands/apps/environments/delete.js').then((mod) => mod.default),
+        'apps:environments:list': await import('./commands/apps/environments/list.js').then((mod) => mod.default),
+        'apps:environments:set': await import('./commands/apps/environments/set.js').then((mod) => mod.default),
+        'apps:environments:unset': await import('./commands/apps/environments/unset.js').then((mod) => mod.default),
         'apps:deployments:create': await import('./commands/apps/deployments/create.js').then((mod) => mod.default),
         'apps:deployments:cancel': await import('./commands/apps/deployments/cancel.js').then((mod) => mod.default),
         'apps:deployments:logs': await import('./commands/apps/deployments/logs.js').then((mod) => mod.default),

package/dist/services/app-environments.js

@@ -5,15 +5,80 @@ class AppEnvironmentsServiceImpl {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
+    async create(dto) {
+        const response = await this.httpClient.post(`/v1/apps/${dto.appId}/environments`, dto, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
+    async delete(dto) {
+        if (dto.id) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/environments/${dto.id}`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+            });
+        }
+        else if (dto.name) {
+            await this.httpClient.delete(`/v1/apps/${dto.appId}/environments`, {
+                headers: {
+                    Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+                },
+                params: {
+                    name: dto.name,
+                },
+            });
+        }
+    }
     async findAll(dto) {
-        const { appId } = dto;
-        const response = await this.httpClient.get(`/v1/apps/${appId}/environments`, {
+        const queryParams = new URLSearchParams();
+        if (dto.limit) {
+            queryParams.append('limit', dto.limit.toString());
+        }
+        if (dto.offset) {
+            queryParams.append('offset', dto.offset.toString());
+        }
+        const queryString = queryParams.toString();
+        const url = queryString
+            ? `/v1/apps/${dto.appId}/environments?${queryString}`
+            : `/v1/apps/${dto.appId}/environments`;
+        const response = await this.httpClient.get(url, {
             headers: {
                 Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
             },
         });
         return response.data;
     }
+    async setVariables(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/variables/set`, dto.variables, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async setSecrets(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/secrets/set`, dto.secrets, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async unsetVariables(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/variables/unset`, dto.keys, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
+    async unsetSecrets(dto) {
+        await this.httpClient.post(`/v1/apps/${dto.appId}/environments/${dto.environmentId}/secrets/unset`, dto.keys, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+    }
 }
 const appEnvironmentsService = new AppEnvironmentsServiceImpl(httpClient);
 export default appEnvironmentsService;

package/dist/utils/app-environments.js

@@ -0,0 +1,34 @@
+/**
+ * Parse key-value pairs from content string.
+ *
+ * Format: KEY=value (one per line)
+ * - Empty lines are ignored
+ * - Lines starting with # are ignored (comments)
+ * - Lines without = are skipped
+ * - Keys and values are trimmed
+ * - Values can contain = characters
+ * - Lines with empty keys are skipped
+ *
+ * @param content - Content string to parse
+ * @returns Array of key-value pairs
+ */
+export function parseKeyValuePairs(content) {
+    const lines = content.split('\n');
+    const pairs = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const separatorIndex = trimmed.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, separatorIndex).trim();
+        const value = trimmed.slice(separatorIndex + 1).trim();
+        if (key) {
+            pairs.push({ key, value });
+        }
+    }
+    return pairs;
+}

package/dist/utils/app-environments.ts.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import { parseKeyValuePairs } from './app-environments.js';
+describe('parseKeyValuePairs', () => {
+    it('should parse valid key-value pairs', () => {
+        const result = parseKeyValuePairs('KEY1=value1\nKEY2=value2');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY2', value: 'value2' },
+        ]);
+    });
+    it('should handle empty lines', () => {
+        const result = parseKeyValuePairs('KEY1=value1\n\nKEY2=value2\n\n');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY2', value: 'value2' },
+        ]);
+    });
+    it('should ignore comments', () => {
+        const result = parseKeyValuePairs('# Comment\nKEY1=value1\n# Another comment\nKEY2=value2');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY2', value: 'value2' },
+        ]);
+    });
+    it('should handle values with = characters', () => {
+        const result = parseKeyValuePairs('KEY1=value=with=equals\nKEY2=a=b');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value=with=equals' },
+            { key: 'KEY2', value: 'a=b' },
+        ]);
+    });
+    it('should trim whitespace from keys and values', () => {
+        const result = parseKeyValuePairs('  KEY1  =  value1  \n  KEY2  =  value2  ');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY2', value: 'value2' },
+        ]);
+    });
+    it('should skip lines without = separator', () => {
+        const result = parseKeyValuePairs('KEY1=value1\nINVALID_LINE\nKEY2=value2');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY2', value: 'value2' },
+        ]);
+    });
+    it('should skip lines with empty keys', () => {
+        const result = parseKeyValuePairs('KEY1=value1\n=value2\nKEY3=value3');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY3', value: 'value3' },
+        ]);
+    });
+    it('should skip lines with empty values', () => {
+        const result = parseKeyValuePairs('KEY1=value1\nKEY2=\nKEY3=value3');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY3', value: 'value3' },
+        ]);
+    });
+    it('should handle empty content', () => {
+        const result = parseKeyValuePairs('');
+        expect(result).toEqual([]);
+    });
+    it('should handle content with only comments', () => {
+        const result = parseKeyValuePairs('# Comment 1\n# Comment 2');
+        expect(result).toEqual([]);
+    });
+    it('should handle mixed valid and invalid lines', () => {
+        const result = parseKeyValuePairs('KEY1=value1\nINVALID\n=nokey\nKEY2=\nKEY3=value3\n# comment\nKEY4=value4');
+        expect(result).toEqual([
+            { key: 'KEY1', value: 'value1' },
+            { key: 'KEY3', value: 'value3' },
+            { key: 'KEY4', value: 'value4' },
+        ]);
+    });
+});

package/package.json

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