@invarn/cibuild 2.0.9 → 2.1.0

package/dist/src/yaml/steps/render-post-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-post-processor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAiJpB,CAAC;AAEpB,eAAO,MAAM,wBAAwB,EAAE,MAsFtC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAMlE"}
+{"version":3,"file":"render-post-processor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MA8JpB,CAAC;AAEpB,eAAO,MAAM,wBAAwB,EAAE,MAsFtC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAMlE"}

package/dist/src/yaml/steps/render-post-processor.js

@@ -61,14 +61,25 @@ export const TRIM_HELPER_SWIFT_SOURCE = [
     '    return CGImageDestinationFinalize(dest)',
     '}',
     '',
-    '// Redraw an image at an exact pixel size (used to match the reference).',
-    'func resize(_ image: CGImage, toWidth w: Int, height h: Int) -> CGImage? {',
+    '// Draw `image` centered on a transparent reference-sized canvas, scaled to fit',
+    '// while PRESERVING its aspect ratio. Unlike `resize` (which stretches to exact',
+    '// dimensions and distorts proportions when the aspect ratios differ), this',
+    '// keeps the rendered shape honest: an aspect mismatch shows as transparent',
+    '// letterbox/pillarbox padding rather than a squished image, while the canvas',
+    '// stays exactly reference-sized so the pair still overlays 1:1.',
+    'func fitPad(_ image: CGImage, toWidth w: Int, height h: Int) -> CGImage? {',
     '    if w <= 0 || h <= 0 { return nil }',
     '    let bytesPerRow = w * 4',
     '    let space = CGColorSpaceCreateDeviceRGB()',
     '    guard let ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: space, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }',
+    '    ctx.clear(CGRect(x: 0, y: 0, width: w, height: h))',
     '    ctx.interpolationQuality = .high',
-    '    ctx.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))',
+    '    let scale = min(Double(w) / Double(image.width), Double(h) / Double(image.height))',
+    '    let drawW = Double(image.width) * scale',
+    '    let drawH = Double(image.height) * scale',
+    '    let originX = (Double(w) - drawW) / 2.0',
+    '    let originY = (Double(h) - drawH) / 2.0',
+    '    ctx.draw(image, in: CGRect(x: originX, y: originY, width: drawW, height: drawH))',
     '    return ctx.makeImage()',
     '}',
     '',
@@ -169,8 +180,10 @@ export const TRIM_HELPER_SWIFT_SOURCE = [
     '    exit(68)',
     '}',
     '',
-    '// Optional aligned output: the trimmed image resized to the reference pixel',
-    '// size, a 1:1 overlay pair. Best-effort; dimensions are reported either way.',
+    '// Optional aligned output: the trimmed image fit onto a reference-sized',
+    '// canvas, preserving aspect ratio (transparent letterbox/pillarbox padding',
+    '// when aspect ratios differ). A reference-sized, undistorted overlay pair.',
+    '// Best-effort; dimensions are reported either way.',
     'var referenceWidth = 0',
     'var referenceHeight = 0',
     'if arguments.count >= 5 {',
@@ -179,7 +192,7 @@ export const TRIM_HELPER_SWIFT_SOURCE = [
     '    if let reference = loadCGImage(referencePath) {',
     '        referenceWidth = reference.width',
     '        referenceHeight = reference.height',
-    '        if let aligned = resize(cropped, toWidth: referenceWidth, height: referenceHeight) {',
+    '        if let aligned = fitPad(cropped, toWidth: referenceWidth, height: referenceHeight) {',
     '            _ = writePNG(aligned, to: alignedPath)',
     '        }',
     '    }',

package/dist/src/yaml/steps/render-post-processor.test.js

@@ -116,13 +116,39 @@ describe('trim helper pixel logic (real toolchain)', () => {
     const BLUE = { r: 0, g: 0, b: 1, a: 1 };
     const WHITE = { r: 1, g: 1, b: 1, a: 1 };
     const PINK = { r: 1, g: 240 / 255, b: 238 / 255, a: 1 };
+    // Prints "<r> <g> <b> <a>" (0..255) for one pixel, so a test can tell padding
+    // (transparent) apart from content (opaque) in an aligned image.
+    const PROBE_SWIFT = [
+        'import Foundation',
+        'import ImageIO',
+        'import CoreGraphics',
+        'let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: CommandLine.arguments[1]) as CFURL, nil)!',
+        'let img = CGImageSourceCreateImageAtIndex(src, 0, nil)!',
+        'let x = Int(CommandLine.arguments[2])!, y = Int(CommandLine.arguments[3])!',
+        'let w = img.width, h = img.height',
+        'var data = [UInt8](repeating: 0, count: w * h * 4)',
+        'let cs = CGColorSpaceCreateDeviceRGB()',
+        'let c = CGContext(data: &data, width: w, height: h, bitsPerComponent: 8, bytesPerRow: w * 4, space: cs, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!',
+        'c.draw(img, in: CGRect(x: 0, y: 0, width: w, height: h))',
+        'let i = y * w * 4 + x * 4',
+        'print("\\(data[i]) \\(data[i+1]) \\(data[i+2]) \\(data[i+3])")',
+    ].join('\n') + '\n';
     function scene() {
         const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-postproc-'));
         dirs.push(dir);
         writeFileSync(join(dir, 'Make.swift'), MAKE_FIXTURE_SWIFT);
         writeFileSync(join(dir, 'Trim.swift'), TRIM_HELPER_SWIFT_SOURCE);
+        writeFileSync(join(dir, 'Probe.swift'), PROBE_SWIFT);
         return dir;
     }
+    // Alpha (0..255) of one pixel in a PNG.
+    function alphaAt(dir, filePath, x, y) {
+        const probe = spawnSync('swift', [join(dir, 'Probe.swift'), filePath, String(x), String(y)], {
+            encoding: 'utf-8',
+        });
+        expect(probe.status).toBe(0);
+        return Number(probe.stdout.trim().split(/\s+/)[3]);
+    }
     function craft(dir, name, w, h, rects) {
         const out = join(dir, name);
         const make = spawnSync('swift', [join(dir, 'Make.swift'), out, JSON.stringify({ w, h, rects })], { encoding: 'utf-8' });
@@ -178,8 +204,8 @@ describe('trim helper pixel logic (real toolchain)', () => {
         const out = join(dir, 'out.png');
         const aligned = join(dir, 'aligned.png');
         const result = trim(dir, input, out, aligned, reference);
-        // The trimmed render is the content; the aligned copy is resized to the
-        // reference pixel size for a 1:1 overlay.
+        // The trimmed render is the content; the aligned copy is fit onto a
+        // reference-sized canvas (preserving aspect) for a 1:1 overlay.
         expect(pngSize(out)).toEqual({ width: 60, height: 40 });
         expect(pngSize(aligned)).toEqual({ width: 100, height: 50 });
         // The TRIMDIMS line reports rendered (trimmed) / reference / pre-trim
@@ -190,5 +216,23 @@ describe('trim helper pixel logic (real toolchain)', () => {
             source: [200, 200],
         });
     }, 600_000);
+    realSwiftTest('fits a wide render into a square reference without distortion (transparent letterbox)', () => {
+        const dir = scene();
+        // Content fills its canvas: a 2:1 render (80x40), all opaque red.
+        const input = craft(dir, 'in.png', 80, 40, [{ x: 0, y: 0, w: 80, h: 40, ...RED }]);
+        // Square 1:1 reference (50x50) — a deliberately different aspect ratio.
+        const reference = craft(dir, 'ref.png', 50, 50, [{ x: 0, y: 0, w: 50, h: 50, ...BLUE }]);
+        const out = join(dir, 'out.png');
+        const aligned = join(dir, 'aligned.png');
+        trim(dir, input, out, aligned, reference);
+        // Aligned stays exactly reference-sized (overlay pair holds).
+        expect(pngSize(aligned)).toEqual({ width: 50, height: 50 });
+        // Aspect preserved: the 2:1 content fits by width (50x25) and is centered,
+        // so both letterbox bands are transparent while the center is opaque
+        // content. A stretch-to-fit would make every one of these opaque.
+        expect(alphaAt(dir, aligned, 25, 3)).toBe(0); // top band
+        expect(alphaAt(dir, aligned, 25, 46)).toBe(0); // bottom band
+        expect(alphaAt(dir, aligned, 25, 25)).toBe(255); // content (center)
+    }, 600_000);
 });
 //# sourceMappingURL=render-post-processor.test.js.map

package/dist/src/yaml/steps/ui-fidelity-preview-android.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui-fidelity-preview-android.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-preview-android.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAsBH,OAAO,KAAK,EAEV,uBAAuB,EACvB,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkBD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AA4CrE;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,uBAAuB,CAsKzB"}
+{"version":3,"file":"ui-fidelity-preview-android.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-preview-android.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAsBH,OAAO,KAAK,EAEV,uBAAuB,EACvB,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAkBD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AAqErE;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,uBAAuB,CA6KzB"}

package/dist/src/yaml/steps/ui-fidelity-preview-android.js

@@ -20,7 +20,7 @@
  */
 import { spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, statSync, writeFileSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 import { parseScale, DEFAULT_SCALE } from './ui-fidelity-render.js';
 import { DEFAULT_GRADLE_TASK, PACKAGE_ARCHIVE_BASENAME, generateAndroidRenderScript, isValidGradleTask, } from './ui-fidelity-render-android.js';
@@ -51,19 +51,44 @@ function commandExists(command, pathPrepend) {
         : spawnSync(`command -v ${command}`, { encoding: 'utf-8', env, shell: true });
     return probe.status === 0 && (probe.stdout || '').trim() !== '';
 }
+/**
+ * Resolve the Android SDK directory: prefer an explicit `ANDROID_HOME` /
+ * `ANDROID_SDK_ROOT` env var (when it points at a real directory), otherwise
+ * fall back to the platform's default install location. This mirrors the
+ * auto-detect the Android build step already does, so a dev machine with a
+ * standard Android Studio install previews locally without the caller (or the
+ * MCP server's launch environment) having to export `ANDROID_HOME`. Returns the
+ * resolved path, or null when no SDK can be found.
+ */
+function resolveAndroidSdk() {
+    const fromEnv = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || '';
+    if (fromEnv && existsSync(fromEnv))
+        return fromEnv;
+    const home = process.env.HOME || homedir();
+    const candidates = [
+        join(home, 'Library', 'Android', 'sdk'), // macOS
+        join(home, 'Android', 'Sdk'), // Linux
+        '/usr/local/android-sdk',
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 /**
  * Report which env-level Android prerequisites are missing: the JVM (`java`) and
- * the SDK (`ANDROID_HOME`/`ANDROID_SDK_ROOT`). Gradle itself ships inside the
+ * the SDK (a resolved [resolveAndroidSdk] path). Gradle itself ships inside the
  * render project (gradlew), so it is not an env-level prerequisite. Returns an
  * empty array when the toolchain is present.
  */
-function missingToolchain(pathPrepend) {
+function missingToolchain(sdk, pathPrepend) {
     const missing = [];
     if (!commandExists('java', pathPrepend))
         missing.push('a JDK (java not on PATH)');
-    const sdk = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || '';
-    if (!sdk || !existsSync(sdk))
-        missing.push('the Android SDK (ANDROID_HOME not set)');
+    if (!sdk) {
+        missing.push('the Android SDK (ANDROID_HOME not set and no SDK at the default location)');
+    }
     return missing;
 }
 /** Resolve an artifact-relative path to absolute, or null. */
@@ -122,7 +147,8 @@ export function renderUiFidelityPreviewAndroid(options) {
     // A render is a heavy Gradle/Robolectric build; if the dev machine has no
     // local Android toolchain at all, fall back to a remote run with a clear
     // message instead of letting the build fail confusingly.
-    const missing = missingToolchain(options.toolchainPath);
+    const androidSdk = resolveAndroidSdk();
+    const missing = missingToolchain(androidSdk, options.toolchainPath);
     if (missing.length > 0) {
         return {
             packageSource: 'inputs',
@@ -187,6 +213,13 @@ export function renderUiFidelityPreviewAndroid(options) {
     if (options.toolchainPath) {
         env.PATH = options.toolchainPath + ':' + (process.env.PATH ?? '');
     }
+    // Export the resolved SDK so gradlew sees it even when ANDROID_HOME was
+    // auto-detected (env unset) rather than already present in process.env.
+    if (androidSdk) {
+        env.ANDROID_HOME = androidSdk;
+        if (!process.env.ANDROID_SDK_ROOT)
+            env.ANDROID_SDK_ROOT = androidSdk;
+    }
     const run = spawnSync('node', ['-e', script], {
         cwd: workDir,
         env,

package/dist/src/yaml/steps/ui-fidelity-preview-android.test.js

@@ -189,8 +189,13 @@ describe('renderUiFidelityPreviewAndroid — missing local toolchain', () => {
     test('reports a clear toolchain-missing build error instead of crashing', () => {
         const savedHome = process.env.ANDROID_HOME;
         const savedRoot = process.env.ANDROID_SDK_ROOT;
+        const savedUserHome = process.env.HOME;
         delete process.env.ANDROID_HOME;
         delete process.env.ANDROID_SDK_ROOT;
+        // Point HOME at an empty dir so the default-location auto-detect
+        // (~/Library/Android/sdk, ~/Android/Sdk) finds nothing — otherwise a dev
+        // machine with the SDK installed would resolve one and this guard wouldn't fire.
+        process.env.HOME = tempDir('ui-fidelity-android-emptyhome-');
         try {
             const result = renderUiFidelityPreviewAndroid({
                 packagePath: gradleProject(),
@@ -211,6 +216,52 @@ describe('renderUiFidelityPreviewAndroid — missing local toolchain', () => {
                 delete process.env.ANDROID_SDK_ROOT;
             else
                 process.env.ANDROID_SDK_ROOT = savedRoot;
+            if (savedUserHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = savedUserHome;
+        }
+    });
+    test('auto-detects the SDK at the default install location when ANDROID_HOME is unset', () => {
+        const savedHome = process.env.ANDROID_HOME;
+        const savedRoot = process.env.ANDROID_SDK_ROOT;
+        const savedUserHome = process.env.HOME;
+        const savedScreens = process.env.FAKE_ROBORAZZI_SCREENS;
+        delete process.env.ANDROID_HOME;
+        delete process.env.ANDROID_SDK_ROOT;
+        // A clean HOME with an SDK at the macOS default location, but no ANDROID_HOME.
+        const fakeHome = tempDir('ui-fidelity-android-home-');
+        mkdirSync(join(fakeHome, 'Library', 'Android', 'sdk'), { recursive: true });
+        process.env.HOME = fakeHome;
+        process.env.FAKE_ROBORAZZI_SCREENS = 'XProof';
+        try {
+            const result = renderUiFidelityPreviewAndroid({
+                packagePath: gradleProject(),
+                screens: [{ screen: 'XProof', reference: writeReference() }],
+                toolchainPath: fakeToolchain(),
+            });
+            // Auto-detected the SDK and rendered, rather than bailing with TOOLCHAIN_MISSING.
+            expect(result.buildError).toBeNull();
+            expect(result.ok).toBe(true);
+            expect(result.screens[0]?.status).toBe('rendered');
+        }
+        finally {
+            if (savedHome === undefined)
+                delete process.env.ANDROID_HOME;
+            else
+                process.env.ANDROID_HOME = savedHome;
+            if (savedRoot === undefined)
+                delete process.env.ANDROID_SDK_ROOT;
+            else
+                process.env.ANDROID_SDK_ROOT = savedRoot;
+            if (savedUserHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = savedUserHome;
+            if (savedScreens === undefined)
+                delete process.env.FAKE_ROBORAZZI_SCREENS;
+            else
+                process.env.FAKE_ROBORAZZI_SCREENS = savedScreens;
         }
     });
 });
@@ -218,7 +269,8 @@ describe('renderUiFidelityPreviewAndroid — missing local toolchain', () => {
 // toolchain and asserts a non-blank paired render at the expected size. Requires
 // the Android toolchain (JDK + SDK) and warm Roborazzi caches; gated behind
 // CIBUILD_UI_FIDELITY_REAL_ANDROID=1 (the Android analog of the iOS real-Swift
-// gate). It needs ANDROID_HOME set on the dev machine.
+// gate). ANDROID_HOME need not be exported — a standard SDK install at the
+// default location (~/Library/Android/sdk etc.) is auto-detected.
 describe('renderUiFidelityPreviewAndroid — real toolchain', () => {
     const realAndroidTest = process.env.CIBUILD_UI_FIDELITY_REAL_ANDROID === '1' ? test : test.skip;
     // A real, decodable 1x1 PNG so the trim helper's reference load/align succeeds.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",