@invarn/cibuild 2.8.5 → 2.8.6

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

@@ -20,6 +20,8 @@ export interface GradleBuildInputs {
     gradle_options?: string;
     variant?: string;
     module?: string;
+    /** JVM arguments to run the Gradle daemon with instead of the project's org.gradle.jvmargs; capped to the machine like the project's own. */
+    jvmargs?: string;
 }
 /**
  * Inputs for android-lint step
@@ -28,6 +30,8 @@ export interface AndroidLintInputs {
     project_location?: string;
     module?: string;
     variant?: string;
+    /** JVM arguments to run the Gradle daemon with instead of the project's org.gradle.jvmargs; capped to the machine like the project's own. */
+    jvmargs?: string;
 }
 /**
  * Inputs for android-unit-test step
@@ -37,6 +41,8 @@ export interface AndroidUnitTestInputs {
     module?: string;
     variant?: string;
     test_filter?: string;
+    /** JVM arguments to run the Gradle daemon with instead of the project's org.gradle.jvmargs; capped to the machine like the project's own. */
+    jvmargs?: string;
 }
 /**
  * Set Java version step executor
@@ -127,6 +133,8 @@ export interface AndroidBuildForUITestingInputs {
     module?: string;
     variant?: string;
     arguments?: string;
+    /** JVM arguments to run the Gradle daemon with instead of the project's org.gradle.jvmargs; capped to the machine like the project's own. */
+    jvmargs?: string;
 }
 /**
  * Builds app APK and test APK for Android instrumented (UI) tests.

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

@@ -1 +1 @@
-{"version":3,"file":"android.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/android.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"android.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/android.ts"],"names":[],"mappings":"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"}

package/dist/src/yaml/steps/android.js

@@ -9,6 +9,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { BaseStepExecutor, javaHomeVersionSpec } from './base.js';
+import { gradleMemoryCommands } from './gradle-memory.js';
 /**
  * Set Java version step executor
  * Sets the Java version to use for Android builds
@@ -459,6 +460,7 @@ export class GradleBuildStepExecutor extends BaseStepExecutor {
         commands.push('  echo "Error: Neither ./gradlew nor gradle command found"');
         commands.push('  exit 1');
         commands.push('fi');
+        commands.push(...gradleMemoryCommands(this.getInput(inputs, 'jvmargs', ''), (v) => this.escapeBash(v)));
         // Build gradle command
         commands.push('');
         commands.push('# Timestamp marker — used to collect only artifacts from this build');
@@ -780,6 +782,7 @@ export class AndroidLintStepExecutor extends BaseStepExecutor {
         commands.push('  echo "Error: Neither ./gradlew nor gradle command found"');
         commands.push('  exit 1');
         commands.push('fi');
+        commands.push(...gradleMemoryCommands(this.getInput(inputs, 'jvmargs', ''), (v) => this.escapeBash(v)));
         // Build lint task name
         commands.push('');
         commands.push('# Run lint');
@@ -969,6 +972,7 @@ export class AndroidUnitTestStepExecutor extends BaseStepExecutor {
         commands.push('  echo "Error: Neither ./gradlew nor gradle command found"');
         commands.push('  exit 1');
         commands.push('fi');
+        commands.push(...gradleMemoryCommands(this.getInput(inputs, 'jvmargs', ''), (v) => this.escapeBash(v)));
         // Build test task name
         commands.push('');
         commands.push('# Run unit tests');
@@ -1036,6 +1040,7 @@ export class AndroidBuildForUITestingStepExecutor extends BaseStepExecutor {
         commands.push('else');
         commands.push('  GRADLE_CMD="gradle"');
         commands.push('fi');
+        commands.push(...gradleMemoryCommands(this.getInput(inputs, 'jvmargs', ''), (v) => this.escapeBash(v)));
         commands.push('');
         // Build both app and test APKs
         const appTask = gradleTaskPath(this.escapeBash(module), `assemble${variantCap}`);

package/dist/src/yaml/steps/gradle-memory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Gradle's daemon heaps, fitted to the machine the build runs on.
+ *
+ * A project's `gradle.properties` sizes its heaps for a developer laptop. On a
+ * 10 GiB build guest, `org.gradle.jvmargs=-Xmx8G` (which the Kotlin daemon
+ * inherits) or `-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g` asks for more
+ * than the machine has, and the kernel kills a daemon mid-build. All the log
+ * then says is "Gradle build daemon disappeared unexpectedly". IacobIonut01/ReFra
+ * and vitorpamplona/amethyst are the two measured cases; ReFra's own CI lowers
+ * its heap to 4g before building.
+ *
+ * Two things, both at run time, in the Gradle project directory:
+ *
+ *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
+ *     daemon and the Kotlin daemon. When their sum is past
+ *     `GRADLE_HEAP_SHARE_PERCENT` of memory, scale both down to fit, and pass
+ *     them on the command line (`-Dorg.gradle.jvmargs=`,
+ *     `-Pkotlin.daemon.jvmargs=`). One line names the old values and the new.
+ *  2. **Say so.** When a Gradle run exits 137 or its output says the daemon
+ *     disappeared, print the kernel's out-of-memory lines and one sentence
+ *     with the machine's memory and what the build asked for.
+ *
+ * Precedence, measured with Gradle 8.14.3 and 9.5.0 (daemon and --no-daemon):
+ * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
+ * home's and the project's `gradle.properties` for the daemon's heap, and
+ * `-P` beats `gradle.properties` for a Gradle property, which is how the
+ * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `GRADLE_OPTS` is not
+ * used: it sizes the client JVM, not the daemon.
+ *
+ * Written as shell functions so what ships is what the tests run. Its lines
+ * start with "Gradle memory:", never with a step-progress marker.
+ */
+/** The share of the machine's memory the two daemon heaps may take together. */
+export declare const GRADLE_HEAP_SHARE_PERCENT = 75;
+export declare const GRADLE_MEMORY_FUNCTIONS = "# This machine's memory in MiB, or nothing when it cannot be read.\ncibuild_mem_mib() {\n  if [ -r /proc/meminfo ]; then\n    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo\n  else\n    local bytes\n    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)\n    if [ -n \"$bytes\" ]; then echo $(( bytes / 1048576 )); fi\n  fi\n}\n\n# $1 a .properties file, $2 a key. Prints \"<line number><TAB><value>\" for the\n# last assignment of the key, or nothing.\ncibuild_prop_line() {\n  [ -f \"$1\" ] || return 0\n  awk -v key=\"$2\" '\n    { line = $0; sub(/^[ \\t]+/, \"\", line) }\n    line ~ /^[#!]/ { next }\n    {\n      k = line; sub(/[ \\t]*[=:].*$/, \"\", k)\n      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, \"\", v); sub(/[ \\t\\r]+$/, \"\", v); found = NR \"\\t\" v }\n    }\n    END { if (found != \"\") print found }\n  ' \"$1\"\n}\n\n# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),\n# or nothing when it has none.\ncibuild_xmx_mib() {\n  printf '%s\\n' \"$1\" | tr ' \\t' '\\n\\n' | awk '\n    /^-Xmx[0-9]+[kKmMgGtT]?$/ {\n      n = substr($0, 5); u = substr(n, length(n))\n      if (u ~ /[0-9]/) { v = n / 1048576 }\n      else {\n        n = substr(n, 1, length(n) - 1)\n        if (u ~ /[kK]/) v = n / 1024\n        else if (u ~ /[mM]/) v = n\n        else if (u ~ /[gG]/) v = n * 1024\n        else v = n * 1048576\n      }\n      r = int(v)\n    }\n    END { if (r != \"\") print r }'\n}\n\n# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every\n# -Xmx replaced by that one (added in front when there was none).\ncibuild_with_xmx() (\n  set -f\n  out=\"\"\n  replaced=0\n  for arg in $1; do\n    case \"$arg\" in\n      -Xmx*) if [ \"$replaced\" -eq 0 ]; then out=\"$out -Xmx${2}m\"; replaced=1; fi ;;\n      *) out=\"$out $arg\" ;;\n    esac\n  done\n  [ \"$replaced\" -eq 1 ] || out=\" -Xmx${2}m$out\"\n  printf '%s' \"${out# }\"\n)\n\n# MiB as GiB with one decimal.\ncibuild_gib() {\n  awk -v m=\"$1\" 'BEGIN { printf \"%.1f\", m / 1024 }'\n}\n\n# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.\ncibuild_scaled_heap() {\n  local v=$(( $1 * $2 / $3 / 64 * 64 ))\n  [ \"$v\" -ge 512 ] || v=512\n  echo \"$v\"\n}\n\n# The plan, from its inputs only, so a test can run it:\n#   $1 this machine's memory in MiB (empty when unknown)\n#   $2 the project's gradle.properties   $3 the Gradle user home's\n#   $4 JVM arguments the pipeline asks for instead (may be empty)\n# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),\n# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when\n# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a\n# daemon is killed).\n#\n# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's\n# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of\n# its own inherits the Gradle daemon's, and in-process compilation has no\n# Kotlin daemon at all.\ncibuild_gradle_memory_plan() {\n  local mem=\"$1\" project=\"$2\" user=\"$3\" preferred=\"$4\" l\n  local jvm=\"\" jvm_at=\"\" kd=\"\" kd_at=\"\" strategy=\"\"\n  CIBUILD_GRADLE_MEMORY_ARGS=()\n  CIBUILD_GRADLE_MEMORY_LINE=\"\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"\"\n\n  if [ -n \"$preferred\" ]; then jvm=\"$preferred\"; jvm_at=\"the pipeline\"; fi\n  for f in \"$user\" \"$project\"; do\n    if [ -z \"$jvm_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" org.gradle.jvmargs)\n      if [ -n \"$l\" ]; then jvm=\"${l#*\t}\"; jvm_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$kd_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.daemon.jvmargs)\n      if [ -n \"$l\" ]; then kd=\"${l#*\t}\"; kd_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$strategy\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.compiler.execution.strategy)\n      strategy=\"${l#*\t}\"\n    fi\n  done\n\n  local g k kd_own=\"\"\n  g=$(cibuild_xmx_mib \"$jvm\")\n  [ -n \"$g\" ] || g=512\n  if [ \"$strategy\" = \"in-process\" ]; then\n    k=0\n  else\n    kd_own=$(cibuild_xmx_mib \"$kd\")\n    k=\"${kd_own:-$g}\"\n  fi\n  local total=$(( g + k ))\n\n  local asked\n  if [ -n \"$jvm_at\" ]; then asked=\"org.gradle.jvmargs=$jvm at ${jvm_at}\"; else asked=\"Gradle's default -Xmx512m\"; fi\n  if [ \"$k\" -eq 0 ]; then\n    asked=\"$asked; Kotlin compiles in-process\"\n  elif [ -n \"$kd_own\" ]; then\n    asked=\"$asked, kotlin.daemon.jvmargs=$kd at ${kd_at}\"\n  else\n    asked=\"$asked; the Kotlin daemon inherits its -Xmx\"\n  fi\n\n  if [ -z \"$mem\" ]; then\n    CIBUILD_GRADLE_MEMORY_SENTENCE=\"This build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked); this machine's memory could not be read.\"\n    if [ -n \"$preferred\" ]; then CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\"); fi\n    return 0\n  fi\n\n  local budget=$(( mem * 75 / 100 ))\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"The build machine has $(cibuild_gib \"$mem\") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked).\"\n\n  if [ \"$total\" -le \"$budget\" ]; then\n    if [ -n \"$preferred\" ]; then\n      CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\")\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line).\"\n    fi\n    return 0\n  fi\n\n  case \"$jvm\" in\n    *\\\\)\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: the declared heaps ask for $(cibuild_gib \"$total\") GiB of this machine's $(cibuild_gib \"$mem\") GiB, but org.gradle.jvmargs at ${jvm_at} continues onto another line, so it is left as it is.\"\n      return 0\n      ;;\n  esac\n\n  local ng nk new_jvm\n  ng=$(cibuild_scaled_heap \"$g\" \"$budget\" \"$total\")\n  new_jvm=$(cibuild_with_xmx \"$jvm\" \"$ng\")\n  CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$new_jvm\")\n  local now=\"Gradle -Xmx${ng}m\"\n  if [ \"$k\" -eq 0 ]; then\n    :\n  elif [ -n \"$kd_own\" ]; then\n    nk=$(cibuild_scaled_heap \"$k\" \"$budget\" \"$total\")\n    CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Pkotlin.daemon.jvmargs=$(cibuild_with_xmx \"$kd\" \"$nk\")\")\n    now=\"$now and the Kotlin daemon -Xmx${nk}m\"\n  else\n    now=\"$now, which the Kotlin daemon inherits\"\n  fi\n  CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: this machine has $(cibuild_gib \"$mem\") GiB and the declared heaps ask for $(cibuild_gib \"$total\") GiB ($asked), past the $(cibuild_gib \"$budget\") GiB this build allows them. Running with $now, set on the command line.\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now.\"\n}\n\n# The kernel's out-of-memory lines, if this user may read the kernel log.\n# Linux guests restrict dmesg to root by default; their build user has\n# non-interactive sudo, so that is the second try.\ncibuild_kernel_oom_lines() {\n  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |\n    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true\n}\n\n# $1 Gradle's exit status, $2 a file holding its output. Says so when the\n# failure is a killed daemon rather than a failed build.\ncibuild_gradle_memory_report() {\n  if [ \"$1\" -ne 137 ] && ! grep -q \"daemon disappeared unexpectedly\" \"$2\" 2>/dev/null; then\n    return 0\n  fi\n  local oom\n  oom=$(cibuild_kernel_oom_lines)\n  echo \"\"\n  echo \"Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1).\"\n  if [ -n \"$oom\" ]; then\n    echo \"The kernel's out-of-memory lines:\"\n    printf '%s\\n' \"$oom\" | sed 's/^/    /'\n  else\n    echo \"The kernel log shows no out-of-memory kill, or this machine does not let the build read it.\"\n  fi\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_SENTENCE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_SENTENCE\"; fi\n}\n\n# Runs Gradle with the plan's arguments, and reports a killed daemon.\ncibuild_gradle() {\n  local log rc\n  log=$(mktemp)\n  set +e\n  \"$CIBUILD_GRADLE_BIN\" \"${CIBUILD_GRADLE_MEMORY_ARGS[@]}\" \"$@\" 2>&1 | tee \"$log\"\n  rc=${PIPESTATUS[0]}\n  set -e\n  if [ \"$rc\" -ne 0 ]; then cibuild_gradle_memory_report \"$rc\" \"$log\" || true; fi\n  rm -f \"$log\"\n  return \"$rc\"\n}\n\n# $1 JVM arguments the pipeline asks for (may be empty). Run in the Gradle\n# project directory, after GRADLE_CMD is chosen.\ncibuild_gradle_memory_cap() {\n  cibuild_gradle_memory_plan \"$(cibuild_mem_mib || true)\" \"gradle.properties\" \\\n    \"${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties\" \"$1\"\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_LINE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_LINE\"; fi\n  CIBUILD_GRADLE_BIN=\"$GRADLE_CMD\"\n  GRADLE_CMD=cibuild_gradle\n}";
+/**
+ * The commands a Gradle step runs once it has chosen `GRADLE_CMD` and is in
+ * the project directory. Afterwards `$GRADLE_CMD` runs Gradle with the plan's
+ * arguments and reports a killed daemon.
+ *
+ * `jvmargs` is what the pipeline asks for instead of the project's
+ * `org.gradle.jvmargs` (a value the repository's own CI sets, say); the cap
+ * still applies to it.
+ */
+export declare function gradleMemoryCommands(jvmargs: string, escape: (value: string) => string): string[];
+//# sourceMappingURL=gradle-memory.d.ts.map

package/dist/src/yaml/steps/gradle-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-memory.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,eAAO,MAAM,uBAAuB,i/QA4NlC,CAAC;AAEH;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,EAAE,CAEjG"}

package/dist/src/yaml/steps/gradle-memory.js

@@ -0,0 +1,268 @@
+/**
+ * Gradle's daemon heaps, fitted to the machine the build runs on.
+ *
+ * A project's `gradle.properties` sizes its heaps for a developer laptop. On a
+ * 10 GiB build guest, `org.gradle.jvmargs=-Xmx8G` (which the Kotlin daemon
+ * inherits) or `-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g` asks for more
+ * than the machine has, and the kernel kills a daemon mid-build. All the log
+ * then says is "Gradle build daemon disappeared unexpectedly". IacobIonut01/ReFra
+ * and vitorpamplona/amethyst are the two measured cases; ReFra's own CI lowers
+ * its heap to 4g before building.
+ *
+ * Two things, both at run time, in the Gradle project directory:
+ *
+ *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
+ *     daemon and the Kotlin daemon. When their sum is past
+ *     `GRADLE_HEAP_SHARE_PERCENT` of memory, scale both down to fit, and pass
+ *     them on the command line (`-Dorg.gradle.jvmargs=`,
+ *     `-Pkotlin.daemon.jvmargs=`). One line names the old values and the new.
+ *  2. **Say so.** When a Gradle run exits 137 or its output says the daemon
+ *     disappeared, print the kernel's out-of-memory lines and one sentence
+ *     with the machine's memory and what the build asked for.
+ *
+ * Precedence, measured with Gradle 8.14.3 and 9.5.0 (daemon and --no-daemon):
+ * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
+ * home's and the project's `gradle.properties` for the daemon's heap, and
+ * `-P` beats `gradle.properties` for a Gradle property, which is how the
+ * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `GRADLE_OPTS` is not
+ * used: it sizes the client JVM, not the daemon.
+ *
+ * Written as shell functions so what ships is what the tests run. Its lines
+ * start with "Gradle memory:", never with a step-progress marker.
+ */
+/** The share of the machine's memory the two daemon heaps may take together. */
+export const GRADLE_HEAP_SHARE_PERCENT = 75;
+export const GRADLE_MEMORY_FUNCTIONS = `# This machine's memory in MiB, or nothing when it cannot be read.
+cibuild_mem_mib() {
+  if [ -r /proc/meminfo ]; then
+    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo
+  else
+    local bytes
+    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)
+    if [ -n "$bytes" ]; then echo $(( bytes / 1048576 )); fi
+  fi
+}
+
+# $1 a .properties file, $2 a key. Prints "<line number><TAB><value>" for the
+# last assignment of the key, or nothing.
+cibuild_prop_line() {
+  [ -f "$1" ] || return 0
+  awk -v key="$2" '
+    { line = $0; sub(/^[ \\t]+/, "", line) }
+    line ~ /^[#!]/ { next }
+    {
+      k = line; sub(/[ \\t]*[=:].*$/, "", k)
+      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, "", v); sub(/[ \\t\\r]+$/, "", v); found = NR "\\t" v }
+    }
+    END { if (found != "") print found }
+  ' "$1"
+}
+
+# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),
+# or nothing when it has none.
+cibuild_xmx_mib() {
+  printf '%s\\n' "$1" | tr ' \\t' '\\n\\n' | awk '
+    /^-Xmx[0-9]+[kKmMgGtT]?$/ {
+      n = substr($0, 5); u = substr(n, length(n))
+      if (u ~ /[0-9]/) { v = n / 1048576 }
+      else {
+        n = substr(n, 1, length(n) - 1)
+        if (u ~ /[kK]/) v = n / 1024
+        else if (u ~ /[mM]/) v = n
+        else if (u ~ /[gG]/) v = n * 1024
+        else v = n * 1048576
+      }
+      r = int(v)
+    }
+    END { if (r != "") print r }'
+}
+
+# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every
+# -Xmx replaced by that one (added in front when there was none).
+cibuild_with_xmx() (
+  set -f
+  out=""
+  replaced=0
+  for arg in $1; do
+    case "$arg" in
+      -Xmx*) if [ "$replaced" -eq 0 ]; then out="$out -Xmx\${2}m"; replaced=1; fi ;;
+      *) out="$out $arg" ;;
+    esac
+  done
+  [ "$replaced" -eq 1 ] || out=" -Xmx\${2}m$out"
+  printf '%s' "\${out# }"
+)
+
+# MiB as GiB with one decimal.
+cibuild_gib() {
+  awk -v m="$1" 'BEGIN { printf "%.1f", m / 1024 }'
+}
+
+# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.
+cibuild_scaled_heap() {
+  local v=$(( $1 * $2 / $3 / 64 * 64 ))
+  [ "$v" -ge 512 ] || v=512
+  echo "$v"
+}
+
+# The plan, from its inputs only, so a test can run it:
+#   $1 this machine's memory in MiB (empty when unknown)
+#   $2 the project's gradle.properties   $3 the Gradle user home's
+#   $4 JVM arguments the pipeline asks for instead (may be empty)
+# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),
+# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when
+# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a
+# daemon is killed).
+#
+# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's
+# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of
+# its own inherits the Gradle daemon's, and in-process compilation has no
+# Kotlin daemon at all.
+cibuild_gradle_memory_plan() {
+  local mem="$1" project="$2" user="$3" preferred="$4" l
+  local jvm="" jvm_at="" kd="" kd_at="" strategy=""
+  CIBUILD_GRADLE_MEMORY_ARGS=()
+  CIBUILD_GRADLE_MEMORY_LINE=""
+  CIBUILD_GRADLE_MEMORY_SENTENCE=""
+
+  if [ -n "$preferred" ]; then jvm="$preferred"; jvm_at="the pipeline"; fi
+  for f in "$user" "$project"; do
+    if [ -z "$jvm_at" ]; then
+      l=$(cibuild_prop_line "$f" org.gradle.jvmargs)
+      if [ -n "$l" ]; then jvm="\${l#*	}"; jvm_at="$f:\${l%%	*}"; fi
+    fi
+    if [ -z "$kd_at" ]; then
+      l=$(cibuild_prop_line "$f" kotlin.daemon.jvmargs)
+      if [ -n "$l" ]; then kd="\${l#*	}"; kd_at="$f:\${l%%	*}"; fi
+    fi
+    if [ -z "$strategy" ]; then
+      l=$(cibuild_prop_line "$f" kotlin.compiler.execution.strategy)
+      strategy="\${l#*	}"
+    fi
+  done
+
+  local g k kd_own=""
+  g=$(cibuild_xmx_mib "$jvm")
+  [ -n "$g" ] || g=512
+  if [ "$strategy" = "in-process" ]; then
+    k=0
+  else
+    kd_own=$(cibuild_xmx_mib "$kd")
+    k="\${kd_own:-$g}"
+  fi
+  local total=$(( g + k ))
+
+  local asked
+  if [ -n "$jvm_at" ]; then asked="org.gradle.jvmargs=$jvm at \${jvm_at}"; else asked="Gradle's default -Xmx512m"; fi
+  if [ "$k" -eq 0 ]; then
+    asked="$asked; Kotlin compiles in-process"
+  elif [ -n "$kd_own" ]; then
+    asked="$asked, kotlin.daemon.jvmargs=$kd at \${kd_at}"
+  else
+    asked="$asked; the Kotlin daemon inherits its -Xmx"
+  fi
+
+  if [ -z "$mem" ]; then
+    CIBUILD_GRADLE_MEMORY_SENTENCE="This build's Gradle and Kotlin daemons asked for $(cibuild_gib "$total") GiB ($asked); this machine's memory could not be read."
+    if [ -n "$preferred" ]; then CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$preferred"); fi
+    return 0
+  fi
+
+  local budget=$(( mem * ${GRADLE_HEAP_SHARE_PERCENT} / 100 ))
+  CIBUILD_GRADLE_MEMORY_SENTENCE="The build machine has $(cibuild_gib "$mem") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib "$total") GiB ($asked)."
+
+  if [ "$total" -le "$budget" ]; then
+    if [ -n "$preferred" ]; then
+      CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$preferred")
+      CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line)."
+    fi
+    return 0
+  fi
+
+  case "$jvm" in
+    *\\\\)
+      CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: the declared heaps ask for $(cibuild_gib "$total") GiB of this machine's $(cibuild_gib "$mem") GiB, but org.gradle.jvmargs at \${jvm_at} continues onto another line, so it is left as it is."
+      return 0
+      ;;
+  esac
+
+  local ng nk new_jvm
+  ng=$(cibuild_scaled_heap "$g" "$budget" "$total")
+  new_jvm=$(cibuild_with_xmx "$jvm" "$ng")
+  CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$new_jvm")
+  local now="Gradle -Xmx\${ng}m"
+  if [ "$k" -eq 0 ]; then
+    :
+  elif [ -n "$kd_own" ]; then
+    nk=$(cibuild_scaled_heap "$k" "$budget" "$total")
+    CIBUILD_GRADLE_MEMORY_ARGS+=("-Pkotlin.daemon.jvmargs=$(cibuild_with_xmx "$kd" "$nk")")
+    now="$now and the Kotlin daemon -Xmx\${nk}m"
+  else
+    now="$now, which the Kotlin daemon inherits"
+  fi
+  CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: this machine has $(cibuild_gib "$mem") GiB and the declared heaps ask for $(cibuild_gib "$total") GiB ($asked), past the $(cibuild_gib "$budget") GiB this build allows them. Running with $now, set on the command line."
+  CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now."
+}
+
+# The kernel's out-of-memory lines, if this user may read the kernel log.
+# Linux guests restrict dmesg to root by default; their build user has
+# non-interactive sudo, so that is the second try.
+cibuild_kernel_oom_lines() {
+  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |
+    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true
+}
+
+# $1 Gradle's exit status, $2 a file holding its output. Says so when the
+# failure is a killed daemon rather than a failed build.
+cibuild_gradle_memory_report() {
+  if [ "$1" -ne 137 ] && ! grep -q "daemon disappeared unexpectedly" "$2" 2>/dev/null; then
+    return 0
+  fi
+  local oom
+  oom=$(cibuild_kernel_oom_lines)
+  echo ""
+  echo "Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1)."
+  if [ -n "$oom" ]; then
+    echo "The kernel's out-of-memory lines:"
+    printf '%s\\n' "$oom" | sed 's/^/    /'
+  else
+    echo "The kernel log shows no out-of-memory kill, or this machine does not let the build read it."
+  fi
+  if [ -n "$CIBUILD_GRADLE_MEMORY_SENTENCE" ]; then echo "$CIBUILD_GRADLE_MEMORY_SENTENCE"; fi
+}
+
+# Runs Gradle with the plan's arguments, and reports a killed daemon.
+cibuild_gradle() {
+  local log rc
+  log=$(mktemp)
+  set +e
+  "$CIBUILD_GRADLE_BIN" "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}" "$@" 2>&1 | tee "$log"
+  rc=\${PIPESTATUS[0]}
+  set -e
+  if [ "$rc" -ne 0 ]; then cibuild_gradle_memory_report "$rc" "$log" || true; fi
+  rm -f "$log"
+  return "$rc"
+}
+
+# $1 JVM arguments the pipeline asks for (may be empty). Run in the Gradle
+# project directory, after GRADLE_CMD is chosen.
+cibuild_gradle_memory_cap() {
+  cibuild_gradle_memory_plan "$(cibuild_mem_mib || true)" "gradle.properties" \\
+    "\${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties" "$1"
+  if [ -n "$CIBUILD_GRADLE_MEMORY_LINE" ]; then echo "$CIBUILD_GRADLE_MEMORY_LINE"; fi
+  CIBUILD_GRADLE_BIN="$GRADLE_CMD"
+  GRADLE_CMD=cibuild_gradle
+}`;
+/**
+ * The commands a Gradle step runs once it has chosen `GRADLE_CMD` and is in
+ * the project directory. Afterwards `$GRADLE_CMD` runs Gradle with the plan's
+ * arguments and reports a killed daemon.
+ *
+ * `jvmargs` is what the pipeline asks for instead of the project's
+ * `org.gradle.jvmargs` (a value the repository's own CI sets, say); the cap
+ * still applies to it.
+ */
+export function gradleMemoryCommands(jvmargs, escape) {
+    return ['', GRADLE_MEMORY_FUNCTIONS, '', `cibuild_gradle_memory_cap '${escape(jvmargs)}'`];
+}
+//# sourceMappingURL=gradle-memory.js.map

package/dist/src/yaml/steps/gradle-memory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gradle-memory.test.d.ts.map

package/dist/src/yaml/steps/gradle-memory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-memory.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.test.ts"],"names":[],"mappings":""}

package/dist/src/yaml/steps/gradle-memory.test.js

@@ -0,0 +1,197 @@
+/**
+ * Gradle's daemon heaps, fitted to the build machine; and a killed daemon,
+ * named as one.
+ *
+ * The fixtures are the `gradle.properties` of IacobIonut01/ReFra
+ * (`-Xmx8G`, inherited by the Kotlin daemon) and vitorpamplona/amethyst
+ * (`-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g`). Both died on a 10 GiB
+ * build machine with nothing in the log but "Gradle build daemon disappeared
+ * unexpectedly".
+ *
+ * The shell under test is the one that ships: it is executed here, not
+ * re-implemented.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AndroidBuildForUITestingStepExecutor, AndroidLintStepExecutor, AndroidUnitTestStepExecutor, GradleBuildStepExecutor, } from "./android.js";
+import { GRADLE_MEMORY_FUNCTIONS } from "./gradle-memory.js";
+import { testConfig } from "./test-config.js";
+const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), "../../../test/fixtures/gradle-memory");
+let dir;
+beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "cibuild-gradle-memory-"));
+});
+afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+});
+/** Run the shipped plan in `dir`, the way the step does, with a given memory. */
+function plan(memMib, preferred = "", userHome = join(dir, "no-user-home")) {
+    const script = `${GRADLE_MEMORY_FUNCTIONS}
+cibuild_gradle_memory_plan "$1" gradle.properties "$2/gradle.properties" "$3"
+for a in "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}"; do printf 'ARG %s\\n' "$a"; done
+printf 'LINE %s\\n' "$CIBUILD_GRADLE_MEMORY_LINE"
+printf 'SENTENCE %s\\n' "$CIBUILD_GRADLE_MEMORY_SENTENCE"`;
+    const out = execFileSync("bash", ["-c", script, "plan", memMib, userHome, preferred], {
+        cwd: dir,
+        encoding: "utf-8",
+    });
+    const lines = out.split("\n");
+    return {
+        args: lines.filter((l) => l.startsWith("ARG ")).map((l) => l.slice(4)),
+        line: (lines.find((l) => l.startsWith("LINE ")) ?? "").slice(5),
+        sentence: (lines.find((l) => l.startsWith("SENTENCE ")) ?? "").slice(9),
+    };
+}
+const TEN_GIB = "10240";
+describe("cibuild_gradle_memory_plan", () => {
+    test("ReFra: -Xmx8G, inherited by the Kotlin daemon, is capped on a 10 GiB machine", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        const p = plan(TEN_GIB);
+        // 75% of 10 GiB, halved because the Kotlin daemon inherits it. Their own
+        // CI runs 4g.
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -Dfile.encoding=UTF-8"]);
+        expect(p.line).toContain("org.gradle.jvmargs=-Xmx8G -Dfile.encoding=UTF-8 at gradle.properties:9");
+        expect(p.line).toContain("16.0 GiB");
+        expect(p.line).toContain("-Xmx3840m");
+        expect(p.sentence).toMatch(/^The build machine has 10\.0 GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
+    });
+    test("amethyst: both heaps are scaled, and the Kotlin one keeps its other flags", () => {
+        copyFileSync(join(FIXTURES, "amethyst.gradle.properties"), join(dir, "gradle.properties"));
+        const p = plan(TEN_GIB);
+        expect(p.args).toEqual([
+            "-Dorg.gradle.jvmargs=-Xmx3264m -Dfile.encoding=UTF-8",
+            "-Pkotlin.daemon.jvmargs=-Xmx4352m -XX:MaxMetaspaceSize=2g",
+        ]);
+        expect(p.line).toContain("kotlin.daemon.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=2g at gradle.properties:27");
+        expect(p.line).toContain("14.0 GiB");
+    });
+    test("heaps that fit are left alone, and nothing is printed", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        const p = plan("65536");
+        expect(p.args).toEqual([]);
+        expect(p.line).toBe("");
+        expect(p.sentence).toContain("asked for 16.0 GiB");
+    });
+    test("a project that declares nothing gets Gradle's default and no cap", () => {
+        const p = plan(TEN_GIB);
+        expect(p.args).toEqual([]);
+        expect(p.sentence).toContain("Gradle's default -Xmx512m");
+    });
+    test("in-process Kotlin compilation has no Kotlin daemon to count", () => {
+        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx4g\nkotlin.compiler.execution.strategy=in-process\n");
+        expect(plan("6144").args).toEqual([]);
+        expect(plan("4096").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3072m"]);
+    });
+    test("the Gradle user home's value wins over the project's, as in Gradle", () => {
+        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx1g\n");
+        const home = join(dir, "home");
+        mkdirSync(home);
+        writeFileSync(join(home, "gradle.properties"), "org.gradle.jvmargs=-Xmx6g -XX:+UseParallelGC\n");
+        const p = plan(TEN_GIB, "", home);
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -XX:+UseParallelGC"]);
+        expect(p.line).toContain(`at ${home}/gradle.properties:1`);
+    });
+    test("JVM arguments the pipeline asks for replace the project's, and are still capped", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        const fits = plan(TEN_GIB, "-Xmx2g -Dfile.encoding=UTF-8");
+        expect(fits.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8"]);
+        expect(fits.line).toContain("as the pipeline asks");
+        const capped = plan("4096", "-Xmx4g -Dfile.encoding=UTF-8");
+        expect(capped.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx1536m -Dfile.encoding=UTF-8"]);
+        expect(capped.line).toContain("at the pipeline");
+    });
+    test("a value continued onto another line is left as it is, and says so", () => {
+        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx12g \\\n  -Dfile.encoding=UTF-8\n");
+        const p = plan(TEN_GIB);
+        expect(p.args).toEqual([]);
+        expect(p.line).toContain("continues onto another line");
+    });
+    test("an unknown machine size caps nothing", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        const p = plan("");
+        expect(p.args).toEqual([]);
+        expect(p.sentence).toContain("could not be read");
+    });
+    test("-Xmx in every unit, and a comment is not an assignment", () => {
+        writeFileSync(join(dir, "gradle.properties"), "# org.gradle.jvmargs=-Xmx64g\norg.gradle.jvmargs = -Xms1g -Xmx6144m\nkotlin.daemon.jvmargs:-Xmx4194304k\n");
+        const p = plan("8192");
+        expect(p.args).toEqual([
+            "-Dorg.gradle.jvmargs=-Xms1g -Xmx3648m",
+            "-Pkotlin.daemon.jvmargs=-Xmx2432m",
+        ]);
+    });
+});
+/** A directory standing in for PATH, with a fake `dmesg` that prints `oom`. */
+function fakeBin(oom) {
+    const bin = join(dir, "bin");
+    mkdirSync(bin, { recursive: true });
+    writeFileSync(join(bin, "dmesg"), `#!/bin/bash\nprintf '%s\\n' ${JSON.stringify(oom)}\n`);
+    chmodSync(join(bin, "dmesg"), 0o755);
+    return bin;
+}
+/** A `./gradlew` that records its arguments and fails the way it is told. */
+function fakeGradlew(body) {
+    writeFileSync(join(dir, "gradlew"), `#!/bin/bash\nprintf '%s\\n' "$@" > "$(dirname "$0")/gradlew-args"\n${body}\n`);
+    chmodSync(join(dir, "gradlew"), 0o755);
+}
+function runStep(script, bin) {
+    writeFileSync(join(dir, "step.sh"), script);
+    return spawnSync("bash", [join(dir, "step.sh")], {
+        cwd: dir,
+        encoding: "utf-8",
+        env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, JAVA_HOME: "", CIBUILD_SOURCE_DIR: "" },
+    });
+}
+describe("the Gradle steps", () => {
+    const OOM_LINE = "[  412.9] Out of memory: Killed process 4242 (java) total-vm:14680064kB, anon-rss:9437184kB";
+    test("a killed daemon prints the kernel's out-of-memory lines and the sentence, and still fails", async () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        fakeGradlew('echo "FAILURE: Build failed with an exception."\necho "Gradle build daemon disappeared unexpectedly (it may have been killed or may have crashed)"\nexit 1');
+        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(OOM_LINE));
+        expect(run.status).toBe(1);
+        expect(run.stdout).toContain("Gradle memory: a Gradle daemon was killed rather than failing the build (exit 1).");
+        expect(run.stdout).toContain(`    ${OOM_LINE}`);
+        expect(run.stdout).toMatch(/The build machine has [0-9.]+ GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
+        expect(run.stdout).not.toContain("Gradle build completed successfully");
+    });
+    test("an ordinary failure says nothing about memory", async () => {
+        fakeGradlew('echo "Compilation error"\nexit 1');
+        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(OOM_LINE));
+        expect(run.status).toBe(1);
+        expect(run.stdout).not.toContain("Gradle memory:");
+    });
+    test("the pipeline's jvmargs reach Gradle as one argument, before the task", async () => {
+        fakeGradlew("exit 0");
+        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug", gradle_options: "--stacktrace", jvmargs: "-Xmx256m -Dfile.encoding=UTF-8" }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(""));
+        expect(run.status).toBe(0);
+        const args = execFileSync("cat", [join(dir, "gradlew-args")], { encoding: "utf-8" }).trim().split("\n");
+        expect(args).toEqual(["-Dorg.gradle.jvmargs=-Xmx256m -Dfile.encoding=UTF-8", "assembleDebug", "--stacktrace"]);
+    });
+    test("every Gradle step runs through the plan, and every one is valid bash", async () => {
+        const steps = [
+            await new GradleBuildStepExecutor().execute({}, {}, testConfig),
+            await new AndroidLintStepExecutor().execute({}, {}, testConfig),
+            await new AndroidUnitTestStepExecutor().execute({}, {}, testConfig),
+            await new AndroidBuildForUITestingStepExecutor().execute({}, {}, testConfig),
+        ];
+        for (const step of steps) {
+            const script = step.script;
+            expect(script).toContain("cibuild_gradle_memory_cap ''");
+            execFileSync("bash", ["-n"], { input: script });
+        }
+    });
+    // cibuild's log is parsed for step-progress markers; nothing here may look
+    // like one.
+    test("no line the functions print can be taken for a step-progress marker", () => {
+        for (const line of GRADLE_MEMORY_FUNCTIONS.split("\n")) {
+            expect(line).not.toMatch(/INVARN_(STEP|PHASE)|▸/);
+        }
+    });
+});
+//# sourceMappingURL=gradle-memory.test.js.map

package/package.json

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