@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/envman/envman.js

@@ -1,361 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,236 +0,0 @@
-/**
- * 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/envstore-round-trip.test.d.ts

@@ -1,27 +0,0 @@
-/**
- * A build whose HEAD commit has a multi-line message completes every step.
- *
- * This is the regression that started the whole thread. On 2026-08-30 the first
- * real `invarn setup` proof died of it: `git-clone` publishes the commit body,
- * and every step after it failed loading the envstore —
- *
- *     [step_2] Running: cache-pull
- *     …: line 59: export: `value nothing provides.': not a valid identifier
- *     ✗ Pipeline failed: Step "Install CocoaPods" failed with exit code 1
- *
- * `src/yaml/steps/envstore-loader.test.ts` drives the *reader* with hostile
- * content written by hand, which is the right shape for the defect but stops
- * short of the thing that actually happened: the value came out of a real
- * repository, through a real producer. This closes that gap — a real
- * `git commit`, the real `git-clone` step reading it with `git log -1
- * --format=%b`, the real `envman` writer (`envmanShellFunction`, the same
- * bytes the runner prepends to every script step), and the real reader in the
- * next step's preamble.
- *
- * The fixture's commit message carries both consequences the PRD names, because
- * they need different bytes to surface: a line that is *not* a valid assignment
- * (which killed the step) and a line that *is* one (which let the commit's
- * author set `PATH` for every step after it).
- */
-export {};
-//# sourceMappingURL=envstore-round-trip.test.d.ts.map

package/dist/src/envman/envstore-round-trip.test.d.ts.map

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