@capawesome/cli 3.10.1 → 3.11.0

package/dist/commands/organizations/create.js

@@ -1,9 +1,9 @@
 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 { hasTTY } from 'std-env';
 import { z } from 'zod';
 export default defineCommand({
     description: 'Create a new organization.',
@@ -17,7 +17,7 @@ export default defineCommand({
             process.exit(1);
         }
         if (!name) {
-            if (!hasTTY) {
+            if (!isInteractive()) {
                 consola.error('You must provide the organization name when running in non-interactive environment.');
                 process.exit(1);
             }

package/dist/commands/organizations/create.test.js

@@ -11,8 +11,8 @@ vi.mock('@/utils/user-config.js');
 vi.mock('@/utils/prompt.js');
 vi.mock('@/services/authorization-service.js');
 vi.mock('consola');
-vi.mock('std-env', () => ({
-    hasTTY: true,
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => true,
 }));
 describe('organizations-create', () => {
     const mockUserConfig = vi.mocked(userConfig);

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/dist/utils/environment.js

@@ -0,0 +1,20 @@
+/**
+ * Detects if the current environment supports interactive prompts.
+ *
+ * For interactive prompts to work, we need:
+ * 1. stdin to be a TTY (to read user input)
+ * 2. stdout to be a TTY (to display the prompt)
+ * 3. Not running in a CI environment
+ *
+ * This is more robust than just checking stdout.isTTY (like std-env's hasTTY),
+ * because interactive prompts require BOTH input and output TTYs.
+ */
+export const isInteractive = () => {
+    // Check if both stdin AND stdout are TTYs
+    const hasInputTTY = Boolean(process.stdin?.isTTY);
+    const hasOutputTTY = Boolean(process.stdout?.isTTY);
+    // Check for CI environment
+    const isCI = Boolean(process.env.CI);
+    // Need BOTH input and output TTY, and not in CI
+    return hasInputTTY && hasOutputTTY && !isCI;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "3.10.1",
+  "version": "3.11.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {
@@ -67,8 +67,7 @@
     "open": "10.2.0",
     "rc9": "2.1.2",
     "semver": "7.6.3",
-    "std-env": "3.9.0",
-    "systeminformation": "5.25.11",
+    "systeminformation": "5.28.5",
     "zod": "4.0.17"
   },
   "devDependencies": {