@invarn/cibuild 1.3.15 → 1.3.17

package/dist/src/yaml/steps/google-play-deploy.js

@@ -0,0 +1,193 @@
+/**
+ * Google Play deploy step implementation
+ * Uploads APK/AAB to Google Play using fastlane supply
+ */
+import { BaseStepExecutor } from './base.js';
+/**
+ * Google Play deploy step executor
+ * Maps google-play-deploy to fastlane supply
+ */
+export class GooglePlayDeployStepExecutor extends BaseStepExecutor {
+    isSkippedInLocalMode() {
+        return true;
+    }
+    getValidationRequirements(inputs, env, _config) {
+        const requirements = [];
+        // service_account_json_key_path only required when JSON content is not available via secret
+        const jsonVarName = inputs.service_account_json_var || 'GOOGLE_PLAY_SERVICE_ACCOUNT_JSON';
+        if (!env[jsonVarName]) {
+            requirements.push(this.requireInput('service_account_json_key_path', inputs, 'Path to service account JSON key file'));
+        }
+        requirements.push(this.requireInput('package_name', inputs, 'Android app package name'));
+        requirements.push(this.requireCommand('fastlane', 'Fastlane for Google Play deployment', 'Install with: gem install fastlane'));
+        return requirements;
+    }
+    async execute(inputs, env, config) {
+        const stepName = 'google-play-deploy';
+        const commands = [];
+        // In local mode, skip entirely — no Google Play credentials available
+        if (config.local) {
+            commands.push('echo "⏭️  google-play-deploy: skipped in local mode"');
+            commands.push('echo "   Google Play upload requires CI credentials."');
+            const script = this.createBashScriptFromCommands(commands, stepName);
+            return this.createScriptStep(script, stepName);
+        }
+        const packageName = this.getInput(inputs, 'package_name', '');
+        const artifactType = this.getInput(inputs, 'artifact_type', 'apk');
+        const isAab = artifactType === 'aab';
+        const defaultAppPath = isAab
+            ? '$CIBUILD_AAB_PATH\n$CIBUILD_APK_PATH'
+            : '$CIBUILD_APK_PATH\n$CIBUILD_AAB_PATH';
+        const appPath = this.getInput(inputs, 'app_path', defaultAppPath);
+        const track = this.getInput(inputs, 'track', 'alpha');
+        const userFraction = this.getInput(inputs, 'user_fraction', '');
+        const status = this.getInput(inputs, 'status', '');
+        const whatsnewsDir = this.getInput(inputs, 'whatsnews_dir', '');
+        const mappingFile = this.getInput(inputs, 'mapping_file', '$CIBUILD_MAPPING_PATH');
+        const dryRun = this.getInput(inputs, 'dry_run', 'false');
+        const verboseLog = this.getInput(inputs, 'verbose_log', 'false');
+        commands.push('# google-play-deploy step → fastlane supply');
+        commands.push('echo "🚀 Deploying to Google Play..."');
+        commands.push('');
+        // Service account JSON: prefer content from secret, fall back to file path
+        const jsonVarName = this.getInput(inputs, 'service_account_json_var', 'GOOGLE_PLAY_SERVICE_ACCOUNT_JSON');
+        const jsonContent = env[jsonVarName] || '';
+        if (jsonContent) {
+            const encoded = Buffer.from(jsonContent).toString('base64');
+            commands.push('# Write service account JSON from GOOGLE_PLAY_SERVICE_ACCOUNT_JSON secret');
+            commands.push('_SA_TEMP_FILE=""');
+            commands.push('_cleanup_sa() { [ -n "$_SA_TEMP_FILE" ] && rm -f "$_SA_TEMP_FILE" 2>/dev/null || true; }');
+            commands.push('trap _cleanup_sa EXIT');
+            commands.push('_SA_TEMP_FILE="$(mktemp /tmp/google-play-sa-XXXXXX.json)"');
+            commands.push(`printf '%s' '${encoded}' | base64 -d > "$_SA_TEMP_FILE"`);
+            commands.push('SERVICE_ACCOUNT_KEY="$_SA_TEMP_FILE"');
+            commands.push('echo "Service account JSON written to temp file"');
+            commands.push('');
+        }
+        else {
+            const serviceAccountKey = this.getInput(inputs, 'service_account_json_key_path', '');
+            commands.push(`SERVICE_ACCOUNT_KEY="${this.escapeBash(serviceAccountKey)}"`);
+            commands.push('');
+        }
+        commands.push(`PACKAGE_NAME="${this.escapeBash(packageName)}"`);
+        commands.push('');
+        commands.push('if [ -z "$SERVICE_ACCOUNT_KEY" ]; then');
+        commands.push('  echo "❌ Error: service_account_json_key_path is required"');
+        commands.push('  echo "   Or set GOOGLE_PLAY_SERVICE_ACCOUNT_JSON in your CI secrets"');
+        commands.push('  exit 1');
+        commands.push('fi');
+        commands.push('');
+        commands.push('if [ ! -f "$SERVICE_ACCOUNT_KEY" ]; then');
+        commands.push('  echo "❌ Error: Service account key file not found: $SERVICE_ACCOUNT_KEY"');
+        commands.push('  exit 1');
+        commands.push('fi');
+        commands.push('');
+        commands.push('if [ -z "$PACKAGE_NAME" ]; then');
+        commands.push('  echo "❌ Error: package_name is required"');
+        commands.push('  exit 1');
+        commands.push('fi');
+        commands.push('');
+        // Resolve app file from app_path (newline-separated list)
+        commands.push('# Locate app file (APK or AAB)');
+        commands.push('APP_FILE=""');
+        commands.push('');
+        // Build a list of candidates from app_path
+        const appPathLines = appPath.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+        if (appPathLines.length > 0) {
+            commands.push('# Check configured app_path candidates');
+            for (const candidate of appPathLines) {
+                commands.push(`if [ -z "$APP_FILE" ] && [ -f "${this.escapeBash(candidate)}" ]; then`);
+                commands.push(`  APP_FILE="${this.escapeBash(candidate)}"`);
+                commands.push('fi');
+            }
+            commands.push('');
+        }
+        // Fall back to env-var resolved paths at runtime (order matches artifact_type preference)
+        commands.push('# Fall back to environment variable paths if not yet resolved');
+        const primaryEnv = isAab ? 'CIBUILD_AAB_PATH' : 'CIBUILD_APK_PATH';
+        const fallbackEnv = isAab ? 'CIBUILD_APK_PATH' : 'CIBUILD_AAB_PATH';
+        commands.push(`if [ -z "$APP_FILE" ] && [ -n "\${${primaryEnv}:-}" ] && [ -f "$${primaryEnv}" ]; then`);
+        commands.push(`  APP_FILE="$${primaryEnv}"`);
+        commands.push('fi');
+        commands.push(`if [ -z "$APP_FILE" ] && [ -n "\${${fallbackEnv}:-}" ] && [ -f "$${fallbackEnv}" ]; then`);
+        commands.push(`  APP_FILE="$${fallbackEnv}"`);
+        commands.push('fi');
+        commands.push('');
+        commands.push('if [ -z "$APP_FILE" ]; then');
+        commands.push('  echo "❌ Error: No APK or AAB file found."');
+        commands.push('  echo "   Set app_path input or ensure CIBUILD_APK_PATH / CIBUILD_AAB_PATH is set."');
+        commands.push('  exit 1');
+        commands.push('fi');
+        commands.push('');
+        commands.push('echo "App file: $APP_FILE"');
+        commands.push('');
+        // Detect AAB vs APK
+        commands.push('# Detect format: AAB or APK');
+        commands.push('APP_FLAG=""');
+        commands.push('if [[ "$APP_FILE" == *.aab ]]; then');
+        commands.push('  APP_FLAG="--aab"');
+        commands.push('  echo "Format: AAB (Android App Bundle)"');
+        commands.push('else');
+        commands.push('  APP_FLAG="--apk"');
+        commands.push('  echo "Format: APK"');
+        commands.push('fi');
+        commands.push('');
+        // Resolve mapping file at runtime
+        commands.push('# Resolve mapping file');
+        commands.push(`MAPPING_FILE="${this.escapeBash(mappingFile)}"`);
+        commands.push('MAPPING_FLAG=""');
+        commands.push('if [ -n "$MAPPING_FILE" ] && [ -f "$MAPPING_FILE" ]; then');
+        commands.push('  MAPPING_FLAG="--mapping \\"$MAPPING_FILE\\""');
+        commands.push('  echo "Mapping file: $MAPPING_FILE"');
+        commands.push('fi');
+        commands.push('');
+        // Build fastlane supply command
+        commands.push('# Build fastlane supply command');
+        commands.push(`TRACK="${this.escapeBash(track)}"`);
+        commands.push('');
+        commands.push('SUPPLY_CMD="fastlane supply"');
+        commands.push('SUPPLY_CMD="$SUPPLY_CMD --json_key \\"$SERVICE_ACCOUNT_KEY\\""');
+        commands.push('SUPPLY_CMD="$SUPPLY_CMD --package_name \\"$PACKAGE_NAME\\""');
+        commands.push('SUPPLY_CMD="$SUPPLY_CMD $APP_FLAG \\"$APP_FILE\\""');
+        commands.push('SUPPLY_CMD="$SUPPLY_CMD --track \\"$TRACK\\""');
+        commands.push('');
+        if (status) {
+            commands.push(`SUPPLY_CMD="$SUPPLY_CMD --release_status \\"${this.escapeBash(status)}\\""`);
+        }
+        if (userFraction) {
+            commands.push(`SUPPLY_CMD="$SUPPLY_CMD --rollout \\"${this.escapeBash(userFraction)}\\""`);
+        }
+        if (whatsnewsDir) {
+            commands.push(`SUPPLY_CMD="$SUPPLY_CMD --whatsnew_paths \\"${this.escapeBash(whatsnewsDir)}\\""`);
+        }
+        commands.push('if [ -n "$MAPPING_FLAG" ]; then');
+        commands.push('  SUPPLY_CMD="$SUPPLY_CMD $MAPPING_FLAG"');
+        commands.push('fi');
+        commands.push('');
+        if (verboseLog === 'true') {
+            commands.push('SUPPLY_CMD="$SUPPLY_CMD --verbose"');
+        }
+        if (dryRun === 'true') {
+            commands.push('SUPPLY_CMD="$SUPPLY_CMD --dry_run"');
+        }
+        commands.push('');
+        commands.push('echo "Running: $SUPPLY_CMD"');
+        commands.push('echo ""');
+        commands.push('');
+        commands.push('# Execute fastlane supply');
+        commands.push('eval "$SUPPLY_CMD"');
+        commands.push('SUPPLY_EXIT=$?');
+        commands.push('');
+        commands.push('if [ $SUPPLY_EXIT -eq 0 ]; then');
+        commands.push('  echo ""');
+        commands.push('  echo "✅ Successfully deployed to Google Play (track: $TRACK)"');
+        commands.push('else');
+        commands.push('  echo ""');
+        commands.push('  echo "❌ Failed to deploy to Google Play (exit code: $SUPPLY_EXIT)"');
+        commands.push('  exit 1');
+        commands.push('fi');
+        const script = this.createBashScriptFromCommands(commands, stepName);
+        return this.createScriptStep(script, stepName);
+    }
+}
+//# sourceMappingURL=google-play-deploy.js.map

package/dist/src/yaml/steps/google-play-deploy.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Google Play deploy step
+ */
+export {};
+//# sourceMappingURL=google-play-deploy.test.d.ts.map

package/dist/src/yaml/steps/google-play-deploy.test.d.ts.map

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

package/dist/src/yaml/steps/google-play-deploy.test.js

@@ -0,0 +1,310 @@
+/**
+ * Unit tests for Google Play deploy step
+ */
+import { describe, test, expect } from '@jest/globals';
+import { GooglePlayDeployStepExecutor } from './google-play-deploy.js';
+describe('GooglePlayDeployStepExecutor', () => {
+    const mockConfig = {
+        artifactsDir: '/ci/artifacts',
+        interpreters: {
+            python: '/usr/bin/python3',
+            ruby: '/usr/bin/ruby',
+            node: '/usr/bin/node',
+            bash: '/bin/bash',
+        },
+        maxConcurrentJobs: 4,
+        paths: {
+            buildsDir: '/ci/builds',
+            cacheDir: '/ci/cache',
+            derivedDataDir: '/ci/derived_data',
+        },
+    };
+    const localConfig = { ...mockConfig, local: true };
+    describe('Basic functionality', () => {
+        test('should create a script step with correct name', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.kind).toBe('script');
+            expect(result.name).toBe('google-play-deploy');
+        });
+        test('should call fastlane supply', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('fastlane supply');
+        });
+        test('should include step label', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('google-play-deploy step → fastlane supply');
+        });
+    });
+    describe('Local mode', () => {
+        test('should skip in local mode', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({}, {}, localConfig);
+            expect(result.script).toContain('skipped in local mode');
+            expect(result.script).not.toContain('fastlane supply');
+        });
+        test('isSkippedInLocalMode should return true', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            expect(executor.isSkippedInLocalMode()).toBe(true);
+        });
+    });
+    describe('Required input validation', () => {
+        test('should error if service_account_json_key_path is empty', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('service_account_json_key_path is required');
+            expect(result.script).toContain('exit 1');
+        });
+        test('should check that service account key file exists on disk', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('Service account key file not found');
+            expect(result.script).toContain('if [ ! -f "$SERVICE_ACCOUNT_KEY" ]');
+        });
+        test('should error if package_name is empty', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json' }, {}, mockConfig);
+            expect(result.script).toContain('package_name is required');
+            expect(result.script).toContain('exit 1');
+        });
+    });
+    describe('App file handling', () => {
+        test('should use provided app_path', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                app_path: '/build/app-release.apk',
+            }, {}, mockConfig);
+            expect(result.script).toContain('/build/app-release.apk');
+        });
+        test('should fall back to CIBUILD_AAB_PATH env var', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('CIBUILD_AAB_PATH');
+        });
+        test('should fall back to CIBUILD_APK_PATH env var', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('CIBUILD_APK_PATH');
+        });
+        test('should error if no app file found', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('No APK or AAB file found');
+            expect(result.script).toContain('exit 1');
+        });
+    });
+    describe('AAB vs APK detection', () => {
+        test('should use --aab flag for .aab files', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                app_path: '/build/app-release.aab',
+            }, {}, mockConfig);
+            expect(result.script).toContain('APP_FLAG="--aab"');
+            expect(result.script).toContain('*.aab');
+        });
+        test('should use --apk flag for non-.aab files', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                app_path: '/build/app-release.apk',
+            }, {}, mockConfig);
+            expect(result.script).toContain('APP_FLAG="--apk"');
+        });
+    });
+    describe('Track input', () => {
+        test('should default to alpha track', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('TRACK="alpha"');
+        });
+        test('should use provided track value', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                track: 'production',
+            }, {}, mockConfig);
+            expect(result.script).toContain('TRACK="production"');
+        });
+        test('should pass track to fastlane supply', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                track: 'internal',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--track \\"$TRACK\\"');
+        });
+    });
+    describe('Optional inputs', () => {
+        test('should pass user_fraction for staged rollout', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                user_fraction: '0.1',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--rollout \\"0.1\\"');
+        });
+        test('should pass status when provided', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                status: 'draft',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--release_status \\"draft\\"');
+        });
+        test('should pass whatsnews_dir when provided', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                whatsnews_dir: './changelogs',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--whatsnew_paths \\"./changelogs\\"');
+        });
+        test('should attempt to resolve mapping_file', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                mapping_file: './mapping.txt',
+            }, {}, mockConfig);
+            expect(result.script).toContain('MAPPING_FILE="./mapping.txt"');
+            expect(result.script).toContain('--mapping');
+        });
+        test('should not pass user_fraction if not provided', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).not.toContain('--rollout');
+        });
+    });
+    describe('Dry run', () => {
+        test('should pass --dry_run when dry_run is true', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                dry_run: 'true',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--dry_run');
+        });
+        test('should not pass --dry_run by default', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).not.toContain('--dry_run');
+        });
+    });
+    describe('Verbose logging', () => {
+        test('should pass --verbose when verbose_log is true', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({
+                service_account_json_key_path: '/keys/service.json',
+                package_name: 'com.example.app',
+                verbose_log: 'true',
+            }, {}, mockConfig);
+            expect(result.script).toContain('--verbose');
+        });
+        test('should not pass --verbose by default', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).not.toContain('--verbose');
+        });
+    });
+    describe('Script structure', () => {
+        test('should include bash error handling directives', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('#!/bin/bash');
+            expect(result.script).toContain('set -e');
+            expect(result.script).toContain('set -o pipefail');
+        });
+        test('should include success message', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('Successfully deployed to Google Play');
+        });
+        test('should include failure message and exit 1', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('Failed to deploy to Google Play');
+            expect(result.script).toContain('exit 1');
+        });
+    });
+    describe('Validation requirements', () => {
+        test('should require service_account_json_key_path input when secret is not set', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const requirements = executor.getValidationRequirements({}, {}, mockConfig);
+            const inputReqs = requirements.filter(r => r.category === 'input');
+            expect(inputReqs.some(r => r.name === 'service_account_json_key_path')).toBe(true);
+        });
+        test('should not require service_account_json_key_path when GOOGLE_PLAY_SERVICE_ACCOUNT_JSON is set', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const requirements = executor.getValidationRequirements({}, { GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: '{"type":"service_account"}' }, mockConfig);
+            const inputReqs = requirements.filter(r => r.category === 'input');
+            expect(inputReqs.some(r => r.name === 'service_account_json_key_path')).toBe(false);
+        });
+        test('should not require service_account_json_key_path when custom service_account_json_var secret is set', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const requirements = executor.getValidationRequirements({ service_account_json_var: 'MY_CUSTOM_SA_JSON' }, { MY_CUSTOM_SA_JSON: '{"type":"service_account"}' }, mockConfig);
+            const inputReqs = requirements.filter(r => r.category === 'input');
+            expect(inputReqs.some(r => r.name === 'service_account_json_key_path')).toBe(false);
+        });
+        test('should require package_name input', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const requirements = executor.getValidationRequirements({}, {}, mockConfig);
+            const inputReqs = requirements.filter(r => r.category === 'input');
+            expect(inputReqs.some(r => r.name === 'package_name')).toBe(true);
+        });
+        test('should require fastlane command', () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const requirements = executor.getValidationRequirements({}, {}, mockConfig);
+            const commandReqs = requirements.filter(r => r.category === 'command');
+            expect(commandReqs.some(r => r.name === 'fastlane')).toBe(true);
+        });
+    });
+    describe('GOOGLE_PLAY_SERVICE_ACCOUNT_JSON secret', () => {
+        const jsonSecret = '{"type":"service_account","project_id":"my-project"}';
+        test('should write secret to temp file when GOOGLE_PLAY_SERVICE_ACCOUNT_JSON is set', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ package_name: 'com.example.app' }, { GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: jsonSecret }, mockConfig);
+            expect(result.script).toContain('GOOGLE_PLAY_SERVICE_ACCOUNT_JSON secret');
+            expect(result.script).toContain('mktemp');
+            expect(result.script).toContain('base64 -d');
+            expect(result.script).toContain('SERVICE_ACCOUNT_KEY="$_SA_TEMP_FILE"');
+        });
+        test('should embed base64-encoded JSON content in the script', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ package_name: 'com.example.app' }, { GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: jsonSecret }, mockConfig);
+            const expected = Buffer.from(jsonSecret).toString('base64');
+            expect(result.script).toContain(expected);
+        });
+        test('should set up EXIT trap to clean up temp file', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ package_name: 'com.example.app' }, { GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: jsonSecret }, mockConfig);
+            expect(result.script).toContain('trap _cleanup_sa EXIT');
+            expect(result.script).toContain('rm -f "$_SA_TEMP_FILE"');
+        });
+        test('should not require service_account_json_key_path when secret is provided', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ package_name: 'com.example.app' }, { GOOGLE_PLAY_SERVICE_ACCOUNT_JSON: jsonSecret }, mockConfig);
+            // Should still call fastlane supply successfully (no early exit from missing path)
+            expect(result.script).toContain('fastlane supply');
+        });
+        test('should still use file path when secret is not set', async () => {
+            const executor = new GooglePlayDeployStepExecutor();
+            const result = await executor.execute({ service_account_json_key_path: '/keys/service.json', package_name: 'com.example.app' }, {}, mockConfig);
+            expect(result.script).toContain('SERVICE_ACCOUNT_KEY="/keys/service.json"');
+            expect(result.script).not.toContain('mktemp');
+        });
+    });
+});
+//# sourceMappingURL=google-play-deploy.test.js.map

package/dist/src/yaml/steps/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Step registry initialization
+ * Registers all available YAML steps
+ */
+/**
+ * Initializes the step registry with all available steps
+ * This function should be called once at application startup
+ */
+export declare function initializeStepRegistry(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/yaml/steps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA+BH;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAm1C7C"}