@invarn/cibuild 1.3.16 → 1.3.18

package/dist/src/envman/envman.js

@@ -0,0 +1,361 @@
+/**
+ * CI Build Environment Variable Manager (envman)
+ *
+ * A tool for managing environment variables between CI/CD pipeline steps.
+ * Similar to Bitrise's envman, this allows scripts to register outputs
+ * that subsequent steps can use as environment variables.
+ *
+ * Usage:
+ *   envman add --key KEY --value 'value'
+ *   envman add --key KEY --valuefile /path/to/file
+ *   echo "value" | envman add --key KEY
+ *   envman run <command>
+ *   envman print [--format json|export]
+ *   envman clear
+ */
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { DEFAULT_STORE_FILE, STORE_VERSION } from './types.js';
+/**
+ * Get the path to the envstore file
+ * Uses ENVMAN_ENVSTORE_PATH env var if set, otherwise defaults to .envstore.json in cwd
+ */
+export function getStorePath() {
+    return process.env.ENVMAN_ENVSTORE_PATH || resolve(process.cwd(), DEFAULT_STORE_FILE);
+}
+/**
+ * Load the environment store from disk
+ * Returns an empty store if file doesn't exist
+ */
+export function loadStore(storePath) {
+    const path = storePath || getStorePath();
+    if (!existsSync(path)) {
+        return createEmptyStore();
+    }
+    try {
+        const content = readFileSync(path, 'utf-8');
+        const store = JSON.parse(content);
+        // Validate store structure
+        if (!store.version || !Array.isArray(store.envs)) {
+            console.error('Warning: Invalid envstore format, creating new store');
+            return createEmptyStore();
+        }
+        return store;
+    }
+    catch (error) {
+        console.error(`Warning: Failed to read envstore at ${path}, creating new store`);
+        return createEmptyStore();
+    }
+}
+/**
+ * Save the environment store to disk
+ */
+export function saveStore(store, storePath) {
+    const path = storePath || getStorePath();
+    writeFileSync(path, JSON.stringify(store, null, 2), 'utf-8');
+}
+/**
+ * Create an empty environment store
+ */
+export function createEmptyStore() {
+    return {
+        version: STORE_VERSION,
+        envs: [],
+    };
+}
+/**
+ * Initialize a new envstore file
+ * Creates an empty store at the specified path (or default)
+ */
+export function init(storePath) {
+    const path = storePath || getStorePath();
+    if (existsSync(path)) {
+        return {
+            success: false,
+            error: `Envstore already exists at ${path}. Use 'clear' to reset.`,
+        };
+    }
+    const store = createEmptyStore();
+    saveStore(store, path);
+    return {
+        success: true,
+        message: `Created envstore at ${path}`,
+    };
+}
+/**
+ * Add an environment variable to the store
+ */
+export function add(options, storePath) {
+    const { key, value, valueFile, sensitive, skipIfEmpty, append } = options;
+    if (!key || key.trim() === '') {
+        return {
+            success: false,
+            error: 'Key is required',
+        };
+    }
+    // Validate key format (must be valid env var name)
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+        return {
+            success: false,
+            error: `Invalid key '${key}'. Must start with letter or underscore, contain only letters, numbers, and underscores.`,
+        };
+    }
+    let finalValue;
+    // Determine the value source
+    if (valueFile) {
+        // Read from file
+        if (!existsSync(valueFile)) {
+            return {
+                success: false,
+                error: `Value file not found: ${valueFile}`,
+            };
+        }
+        finalValue = readFileSync(valueFile, 'utf-8');
+    }
+    else if (value !== undefined) {
+        // Use provided value
+        finalValue = value;
+    }
+    else {
+        return {
+            success: false,
+            error: 'Either --value or --valuefile must be provided',
+        };
+    }
+    // Handle skip if empty
+    if (skipIfEmpty && finalValue.trim() === '') {
+        return {
+            success: true,
+            message: `Skipped empty value for key '${key}'`,
+        };
+    }
+    // Load existing store
+    const store = loadStore(storePath);
+    const now = new Date().toISOString();
+    // Find existing entry
+    const existingIndex = store.envs.findIndex(e => e.key === key);
+    if (existingIndex >= 0) {
+        // Update existing entry
+        const existing = store.envs[existingIndex];
+        if (append) {
+            existing.value += finalValue;
+        }
+        else {
+            existing.value = finalValue;
+        }
+        existing.sensitive = sensitive ?? existing.sensitive;
+        existing.updatedAt = now;
+    }
+    else {
+        // Add new entry
+        const entry = {
+            key,
+            value: finalValue,
+            sensitive: sensitive ?? false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        store.envs.push(entry);
+    }
+    // Save store
+    saveStore(store, storePath);
+    const displayValue = sensitive ? '[REDACTED]' : (finalValue.length > 50 ? finalValue.substring(0, 47) + '...' : finalValue);
+    return {
+        success: true,
+        message: `Added ${key}=${displayValue}`,
+    };
+}
+/**
+ * Add an environment variable from stdin
+ */
+export async function addFromStdin(key, sensitive, storePath) {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            // Remove trailing newline (like envman does)
+            const value = data.replace(/\n$/, '');
+            const result = add({ key, value, sensitive }, storePath);
+            resolve(result);
+        });
+        process.stdin.on('error', (err) => {
+            resolve({
+                success: false,
+                error: `Failed to read from stdin: ${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Get all environment variables from the store as a Record
+ */
+export function getAll(storePath) {
+    const store = loadStore(storePath);
+    const result = {};
+    for (const entry of store.envs) {
+        result[entry.key] = entry.value;
+    }
+    return result;
+}
+/**
+ * Get a single environment variable from the store
+ */
+export function get(key, storePath) {
+    const store = loadStore(storePath);
+    const entry = store.envs.find(e => e.key === key);
+    return entry?.value;
+}
+/**
+ * Print environment variables in various formats
+ */
+export function print(format = 'table', storePath) {
+    const store = loadStore(storePath);
+    switch (format) {
+        case 'json':
+            return JSON.stringify(store.envs.map(e => ({
+                key: e.key,
+                value: e.sensitive ? '[REDACTED]' : e.value,
+                sensitive: e.sensitive,
+            })), null, 2);
+        case 'export':
+            return store.envs.map(e => {
+                const escapedValue = e.value.replace(/'/g, "'\\''");
+                return `export ${e.key}='${escapedValue}'`;
+            }).join('\n');
+        case 'table':
+        default:
+            if (store.envs.length === 0) {
+                return 'No environment variables stored.';
+            }
+            const lines = [];
+            lines.push('┌─────────────────────────────────────────────────────────────────┐');
+            lines.push('│  Environment Variables                                          │');
+            lines.push('├─────────────────────────────────────────────────────────────────┤');
+            for (const entry of store.envs) {
+                const displayValue = entry.sensitive
+                    ? '[REDACTED]'
+                    : (entry.value.length > 40 ? entry.value.substring(0, 37) + '...' : entry.value);
+                const line = `│  ${entry.key.padEnd(20)} = ${displayValue.padEnd(38)}│`;
+                lines.push(line);
+            }
+            lines.push('└─────────────────────────────────────────────────────────────────┘');
+            return lines.join('\n');
+    }
+}
+/**
+ * Run a command with the environment variables from the store
+ */
+export async function run(command, storePath) {
+    if (command.length === 0) {
+        console.error('Error: No command specified');
+        return 1;
+    }
+    // Load environment variables
+    const envVars = getAll(storePath);
+    // Merge with current environment
+    const env = {
+        ...process.env,
+        ...envVars,
+    };
+    // Spawn the command
+    const [cmd, ...args] = command;
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            env,
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.on('error', (err) => {
+            console.error(`Failed to execute command: ${err.message}`);
+            resolve(1);
+        });
+        child.on('exit', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}
+/**
+ * Clear the environment store
+ */
+export function clear(storePath) {
+    const path = storePath || getStorePath();
+    if (!existsSync(path)) {
+        return {
+            success: true,
+            message: 'Envstore does not exist, nothing to clear.',
+        };
+    }
+    try {
+        unlinkSync(path);
+        return {
+            success: true,
+            message: `Cleared envstore at ${path}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to clear envstore: ${error.message}`,
+        };
+    }
+}
+/**
+ * Unset (remove) a specific environment variable from the store
+ */
+export function unset(key, storePath) {
+    const store = loadStore(storePath);
+    const index = store.envs.findIndex(e => e.key === key);
+    if (index === -1) {
+        return {
+            success: false,
+            error: `Key '${key}' not found in envstore`,
+        };
+    }
+    store.envs.splice(index, 1);
+    saveStore(store, storePath);
+    return {
+        success: true,
+        message: `Removed ${key} from envstore`,
+    };
+}
+/**
+ * Generate a bash script that sources the envstore
+ * This can be prepended to step scripts to load environment variables
+ */
+export function generateSourceScript(storePath) {
+    const path = storePath || getStorePath();
+    return `
+# CI Build envman: Load environment variables from store
+if [ -f "${path}" ]; then
+  while IFS= read -r line; do
+    if [ -n "$line" ]; then
+      export "$line"
+    fi
+  done < <(node -e "
+    const fs = require('fs');
+    try {
+      const store = JSON.parse(fs.readFileSync('${path}', 'utf-8'));
+      for (const e of store.envs || []) {
+        const escaped = e.value.replace(/'/g, \"'\\\\\\\\\\\\\\''\" );
+        console.log(e.key + '=' + escaped);
+      }
+    } catch(e) {}
+  ")
+fi
+`;
+}
+/**
+ * Export all environment variables to the current process
+ * Useful for programmatic usage
+ */
+export function exportToProcess(storePath) {
+    const envVars = getAll(storePath);
+    for (const [key, value] of Object.entries(envVars)) {
+        process.env[key] = value;
+    }
+}
+//# sourceMappingURL=envman.js.map

package/dist/src/envman/envman.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for the CI Build Environment Variable Manager (envman)
+ */
+export {};
+//# sourceMappingURL=envman.test.d.ts.map

package/dist/src/envman/envman.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envman.test.d.ts","sourceRoot":"","sources":["../../../src/envman/envman.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/envman/envman.test.js

@@ -0,0 +1,236 @@
+/**
+ * Unit tests for the CI Build Environment Variable Manager (envman)
+ */
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as envman from './envman.js';
+import { STORE_VERSION } from './types.js';
+describe('envman', () => {
+    const testStorePath = path.join(process.cwd(), '.envstore.test.json');
+    beforeEach(() => {
+        // Clean up any existing test store
+        if (fs.existsSync(testStorePath)) {
+            fs.unlinkSync(testStorePath);
+        }
+    });
+    afterEach(() => {
+        // Clean up test store after each test
+        if (fs.existsSync(testStorePath)) {
+            fs.unlinkSync(testStorePath);
+        }
+    });
+    describe('init', () => {
+        test('should create an empty envstore file', () => {
+            const result = envman.init(testStorePath);
+            expect(result.success).toBe(true);
+            expect(fs.existsSync(testStorePath)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(testStorePath, 'utf-8'));
+            expect(content.version).toBe(STORE_VERSION);
+            expect(content.envs).toEqual([]);
+        });
+        test('should fail if envstore already exists', () => {
+            // Create the store first
+            envman.init(testStorePath);
+            // Try to init again
+            const result = envman.init(testStorePath);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('already exists');
+        });
+    });
+    describe('add', () => {
+        test('should add a new environment variable', () => {
+            const result = envman.add({
+                key: 'TEST_VAR',
+                value: 'test_value',
+            }, testStorePath);
+            expect(result.success).toBe(true);
+            const value = envman.get('TEST_VAR', testStorePath);
+            expect(value).toBe('test_value');
+        });
+        test('should update an existing environment variable', () => {
+            // Add initial value
+            envman.add({ key: 'TEST_VAR', value: 'initial' }, testStorePath);
+            // Update value
+            const result = envman.add({ key: 'TEST_VAR', value: 'updated' }, testStorePath);
+            expect(result.success).toBe(true);
+            expect(envman.get('TEST_VAR', testStorePath)).toBe('updated');
+        });
+        test('should append to existing value with --append flag', () => {
+            envman.add({ key: 'TEST_VAR', value: 'hello' }, testStorePath);
+            envman.add({ key: 'TEST_VAR', value: ' world', append: true }, testStorePath);
+            expect(envman.get('TEST_VAR', testStorePath)).toBe('hello world');
+        });
+        test('should read value from file', () => {
+            const valueFilePath = path.join(process.cwd(), '.test-value-file.txt');
+            fs.writeFileSync(valueFilePath, 'value_from_file');
+            try {
+                const result = envman.add({
+                    key: 'FILE_VAR',
+                    valueFile: valueFilePath,
+                }, testStorePath);
+                expect(result.success).toBe(true);
+                expect(envman.get('FILE_VAR', testStorePath)).toBe('value_from_file');
+            }
+            finally {
+                fs.unlinkSync(valueFilePath);
+            }
+        });
+        test('should fail with invalid key name', () => {
+            const result = envman.add({
+                key: '123-invalid',
+                value: 'test',
+            }, testStorePath);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Invalid key');
+        });
+        test('should skip empty values with --skip-if-empty', () => {
+            const result = envman.add({
+                key: 'EMPTY_VAR',
+                value: '  ',
+                skipIfEmpty: true,
+            }, testStorePath);
+            expect(result.success).toBe(true);
+            expect(result.message).toContain('Skipped');
+            expect(envman.get('EMPTY_VAR', testStorePath)).toBeUndefined();
+        });
+        test('should mark sensitive variables', () => {
+            const result = envman.add({
+                key: 'SECRET_VAR',
+                value: 'super_secret',
+                sensitive: true,
+            }, testStorePath);
+            expect(result.success).toBe(true);
+            expect(result.message).toContain('REDACTED');
+            const store = envman.loadStore(testStorePath);
+            const entry = store.envs.find(e => e.key === 'SECRET_VAR');
+            expect(entry?.sensitive).toBe(true);
+        });
+    });
+    describe('get', () => {
+        test('should return undefined for non-existent key', () => {
+            const value = envman.get('NON_EXISTENT', testStorePath);
+            expect(value).toBeUndefined();
+        });
+        test('should return value for existing key', () => {
+            envman.add({ key: 'TEST_VAR', value: 'test_value' }, testStorePath);
+            const value = envman.get('TEST_VAR', testStorePath);
+            expect(value).toBe('test_value');
+        });
+    });
+    describe('getAll', () => {
+        test('should return empty object for empty store', () => {
+            const all = envman.getAll(testStorePath);
+            expect(all).toEqual({});
+        });
+        test('should return all variables as key-value pairs', () => {
+            envman.add({ key: 'VAR1', value: 'value1' }, testStorePath);
+            envman.add({ key: 'VAR2', value: 'value2' }, testStorePath);
+            const all = envman.getAll(testStorePath);
+            expect(all).toEqual({
+                VAR1: 'value1',
+                VAR2: 'value2',
+            });
+        });
+    });
+    describe('unset', () => {
+        test('should remove an existing variable', () => {
+            envman.add({ key: 'TO_REMOVE', value: 'test' }, testStorePath);
+            const result = envman.unset('TO_REMOVE', testStorePath);
+            expect(result.success).toBe(true);
+            expect(envman.get('TO_REMOVE', testStorePath)).toBeUndefined();
+        });
+        test('should fail for non-existent key', () => {
+            const result = envman.unset('NON_EXISTENT', testStorePath);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('not found');
+        });
+    });
+    describe('clear', () => {
+        test('should remove the envstore file', () => {
+            envman.add({ key: 'TEST_VAR', value: 'test' }, testStorePath);
+            expect(fs.existsSync(testStorePath)).toBe(true);
+            const result = envman.clear(testStorePath);
+            expect(result.success).toBe(true);
+            expect(fs.existsSync(testStorePath)).toBe(false);
+        });
+        test('should succeed even if envstore does not exist', () => {
+            const result = envman.clear(testStorePath);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('print', () => {
+        beforeEach(() => {
+            envman.add({ key: 'VAR1', value: 'value1' }, testStorePath);
+            envman.add({ key: 'VAR2', value: 'value2' }, testStorePath);
+        });
+        test('should print in table format by default', () => {
+            const output = envman.print('table', testStorePath);
+            expect(output).toContain('VAR1');
+            expect(output).toContain('value1');
+            expect(output).toContain('VAR2');
+            expect(output).toContain('value2');
+        });
+        test('should print in export format', () => {
+            const output = envman.print('export', testStorePath);
+            expect(output).toContain("export VAR1='value1'");
+            expect(output).toContain("export VAR2='value2'");
+        });
+        test('should print in JSON format', () => {
+            const output = envman.print('json', testStorePath);
+            const parsed = JSON.parse(output);
+            expect(parsed).toHaveLength(2);
+            expect(parsed.find((e) => e.key === 'VAR1')?.value).toBe('value1');
+        });
+        test('should redact sensitive values in table format', () => {
+            envman.add({ key: 'SECRET', value: 'secret_value', sensitive: true }, testStorePath);
+            const output = envman.print('table', testStorePath);
+            expect(output).toContain('SECRET');
+            expect(output).toContain('[REDACTED]');
+            expect(output).not.toContain('secret_value');
+        });
+    });
+    describe('loadStore', () => {
+        test('should return empty store if file does not exist', () => {
+            const store = envman.loadStore(testStorePath);
+            expect(store.version).toBe(STORE_VERSION);
+            expect(store.envs).toEqual([]);
+        });
+        test('should load existing store from file', () => {
+            const testStore = {
+                version: STORE_VERSION,
+                envs: [
+                    { key: 'TEST', value: 'value', createdAt: '', updatedAt: '' },
+                ],
+            };
+            fs.writeFileSync(testStorePath, JSON.stringify(testStore));
+            const store = envman.loadStore(testStorePath);
+            expect(store.envs).toHaveLength(1);
+            expect(store.envs[0].key).toBe('TEST');
+        });
+    });
+    describe('createEmptyStore', () => {
+        test('should create a valid empty store', () => {
+            const store = envman.createEmptyStore();
+            expect(store.version).toBe(STORE_VERSION);
+            expect(store.envs).toEqual([]);
+        });
+    });
+    describe('special characters handling', () => {
+        test('should handle values with single quotes', () => {
+            envman.add({ key: 'QUOTED', value: "it's a test" }, testStorePath);
+            expect(envman.get('QUOTED', testStorePath)).toBe("it's a test");
+            const exported = envman.print('export', testStorePath);
+            expect(exported).toContain('QUOTED');
+        });
+        test('should handle values with newlines', () => {
+            envman.add({ key: 'MULTILINE', value: 'line1\nline2\nline3' }, testStorePath);
+            expect(envman.get('MULTILINE', testStorePath)).toBe('line1\nline2\nline3');
+        });
+        test('should handle empty values', () => {
+            envman.add({ key: 'EMPTY', value: '' }, testStorePath);
+            expect(envman.get('EMPTY', testStorePath)).toBe('');
+        });
+    });
+});
+//# sourceMappingURL=envman.test.js.map

package/dist/src/envman/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * CI Build Environment Variable Manager (envman)
+ *
+ * A tool for managing environment variables between CI/CD pipeline steps.
+ * Similar to Bitrise's envman, this allows scripts to register outputs
+ * that subsequent steps can use as environment variables.
+ *
+ * @example
+ * // In a script step:
+ * // envman add --key BUILD_VERSION --value '1.2.3'
+ * // envman add --key APK_PATH --valuefile ./build/output/path.txt
+ *
+ * @example
+ * // Programmatic usage:
+ * import { add, getAll, run } from './envman/index.js';
+ *
+ * add({ key: 'BUILD_VERSION', value: '1.2.3' });
+ * const envs = getAll();
+ * await run(['gradle', 'assembleRelease']);
+ */
+export * from './envman.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/envman/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/envman/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/src/envman/index.js

@@ -0,0 +1,23 @@
+/**
+ * CI Build Environment Variable Manager (envman)
+ *
+ * A tool for managing environment variables between CI/CD pipeline steps.
+ * Similar to Bitrise's envman, this allows scripts to register outputs
+ * that subsequent steps can use as environment variables.
+ *
+ * @example
+ * // In a script step:
+ * // envman add --key BUILD_VERSION --value '1.2.3'
+ * // envman add --key APK_PATH --valuefile ./build/output/path.txt
+ *
+ * @example
+ * // Programmatic usage:
+ * import { add, getAll, run } from './envman/index.js';
+ *
+ * add({ key: 'BUILD_VERSION', value: '1.2.3' });
+ * const envs = getAll();
+ * await run(['gradle', 'assembleRelease']);
+ */
+export * from './envman.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map