zig-mobile-runner 0.1.0

package/scripts/device-matrix.sh

@@ -0,0 +1,338 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SOURCE="${BASH_SOURCE[0]}"
+while [[ -h "$SOURCE" ]]; do
+  SOURCE_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  if [[ "$SOURCE" != /* ]]; then
+    SOURCE="$SOURCE_DIR/$SOURCE"
+  fi
+done
+
+ROOT="$(cd -P "$(dirname "$SOURCE")/.." && pwd)"
+CALLER_CWD="$(pwd -P)"
+ZMR_BIN="${ZMR_BIN:-$(command -v zmr 2>/dev/null || printf '%s' "$ROOT/zig-out/bin/zmr")}"
+MATRIX=""
+TRACE_ROOT="${TRACE_ROOT:-$CALLER_CWD/traces/matrix-$(date +%Y%m%d-%H%M%S)}"
+MIN_PASS_RATE="${MIN_PASS_RATE:-}"
+MAX_FAILURES="${MAX_FAILURES:-}"
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  scripts/device-matrix.sh --matrix <matrix.json> [--trace-root <dir>] [gate options]
+
+Omit --trace-root to write under traces/matrix-<timestamp> in the caller directory.
+
+Gate options:
+  --min-pass-rate <pct>  Minimum total pass rate percentage.
+  --max-failures <n>     Maximum total failed matrix runs.
+
+Matrix format:
+  {
+    "runs": 2,
+    "appId": "com.example.mobiletest",
+    "devices": [
+      {
+        "name": "android-api-35",
+        "platform": "android",
+        "serial": "emulator-5554",
+        "scenario": ".zmr/android-smoke.json",
+        "adb": "adb",
+        "androidShim": ".zmr/android-shim"
+      },
+      {
+        "name": "ios-18",
+        "platform": "ios",
+        "iosDeviceType": "simulator",
+        "serial": "booted",
+        "scenario": ".zmr/ios-smoke.json",
+        "xcrun": "xcrun",
+        "iosShim": ".zmr/ios-shim"
+      },
+      {
+        "name": "ios-physical",
+        "platform": "ios",
+        "iosDeviceType": "physical",
+        "serial": "<physical-device-id>",
+        "scenario": ".zmr/ios-smoke.json",
+        "xcrun": "xcrun",
+        "iosShim": ".zmr/ios-shim"
+      }
+    ]
+  }
+USAGE
+}
+
+die() {
+  echo "error: $*" >&2
+  exit 2
+}
+
+require_value() {
+  local flag="$1"
+  local value="${2-}"
+  if [[ -z "$value" || "$value" == --* ]]; then
+    die "$flag requires a value"
+  fi
+  printf '%s\n' "$value"
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --matrix)
+      MATRIX="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --trace-root)
+      TRACE_ROOT="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --min-pass-rate)
+      MIN_PASS_RATE="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --max-failures)
+      MAX_FAILURES="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+if [[ -z "$MATRIX" ]]; then
+  echo "error: --matrix is required" >&2
+  usage >&2
+  exit 2
+fi
+
+if [[ ! -f "$MATRIX" ]]; then
+  die "matrix file not found: $MATRIX"
+fi
+
+if [[ ! -x "$ZMR_BIN" ]]; then
+  die "zmr binary is not executable: $ZMR_BIN"
+fi
+
+validate_optional_number() {
+  local name="$1"
+  local value="$2"
+  if [[ -n "$value" && ! "$value" =~ ^[0-9]+([.][0-9]+)?$ ]]; then
+    echo "$name must be a non-negative number" >&2
+    exit 2
+  fi
+}
+
+validate_optional_integer() {
+  local name="$1"
+  local value="$2"
+  if [[ -n "$value" && ! "$value" =~ ^[0-9]+$ ]]; then
+    echo "$name must be a non-negative integer" >&2
+    exit 2
+  fi
+}
+
+validate_optional_number "--min-pass-rate" "$MIN_PASS_RATE"
+validate_optional_integer "--max-failures" "$MAX_FAILURES"
+
+mkdir -p "$TRACE_ROOT"
+ROWS="$TRACE_ROOT/matrix.rows.tsv"
+RESULTS="$TRACE_ROOT/matrix.jsonl"
+SUMMARY="$TRACE_ROOT/summary.json"
+: > "$RESULTS"
+
+python3 - "$MATRIX" > "$ROWS" <<'PY'
+import json
+import sys
+
+path = sys.argv[1]
+with open(path, "r", encoding="utf-8") as fh:
+    matrix = json.load(fh)
+
+runs = int(matrix.get("runs", 1))
+if runs < 1:
+    raise SystemExit("matrix.runs must be >= 1")
+
+default_app_id = matrix.get("appId", "")
+devices = matrix.get("devices")
+if not isinstance(devices, list) or not devices:
+    raise SystemExit("matrix.devices must be a non-empty array")
+
+fields = [
+    "name",
+    "platform",
+    "iosDeviceType",
+    "serial",
+    "scenario",
+    "appId",
+    "adb",
+    "androidShim",
+    "xcrun",
+    "iosShim",
+]
+
+for index, device in enumerate(devices):
+    if not isinstance(device, dict):
+        raise SystemExit(f"matrix.devices[{index}] must be an object")
+    row = {}
+    row["name"] = device.get("name") or device.get("serial") or f"device-{index + 1}"
+    row["platform"] = device.get("platform", "android")
+    row["iosDeviceType"] = device.get("iosDeviceType", "")
+    row["serial"] = device.get("serial", "")
+    row["scenario"] = device.get("scenario", "")
+    row["appId"] = device.get("appId", default_app_id)
+    row["adb"] = device.get("adb", "")
+    row["androidShim"] = device.get("androidShim", "")
+    row["xcrun"] = device.get("xcrun", "")
+    row["iosShim"] = device.get("iosShim", "")
+    if row["platform"] not in {"android", "ios"}:
+        raise SystemExit(f"matrix.devices[{index}].platform must be android or ios")
+    if row["iosDeviceType"] and row["iosDeviceType"] not in {"simulator", "physical"}:
+        raise SystemExit(f"matrix.devices[{index}].iosDeviceType must be simulator or physical")
+    if not row["serial"]:
+        raise SystemExit(f"matrix.devices[{index}].serial is required")
+    if not row["scenario"]:
+        raise SystemExit(f"matrix.devices[{index}].scenario is required")
+    for run in range(1, runs + 1):
+        values = [str(run)]
+        for field in fields:
+            value = str(row[field]).replace("\t", " ")
+            values.append(value if value else "__ZMR_EMPTY__")
+        print("\t".join(values))
+PY
+
+slugify() {
+  printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9._-]+/-/g; s/^-+//; s/-+$//'
+}
+
+decode_matrix_field() {
+  if [[ "$1" == "__ZMR_EMPTY__" ]]; then
+    printf ''
+  else
+    printf '%s' "$1"
+  fi
+}
+
+while IFS=$'\t' read -r run device_name platform ios_device_type serial scenario app_id adb android_shim xcrun ios_shim; do
+  device_name="$(decode_matrix_field "$device_name")"
+  platform="$(decode_matrix_field "$platform")"
+  ios_device_type="$(decode_matrix_field "$ios_device_type")"
+  serial="$(decode_matrix_field "$serial")"
+  scenario="$(decode_matrix_field "$scenario")"
+  app_id="$(decode_matrix_field "$app_id")"
+  adb="$(decode_matrix_field "$adb")"
+  android_shim="$(decode_matrix_field "$android_shim")"
+  xcrun="$(decode_matrix_field "$xcrun")"
+  ios_shim="$(decode_matrix_field "$ios_shim")"
+
+  safe_name="$(slugify "$device_name")"
+  if [[ -z "$safe_name" ]]; then
+    safe_name="device"
+  fi
+  trace_dir="$TRACE_ROOT/$safe_name-run-$run"
+  mkdir -p "$trace_dir"
+
+  zmr_args=(run "$scenario" --platform "$platform" --device "$serial" --trace-dir "$trace_dir")
+  if [[ -n "$ios_device_type" ]]; then
+    zmr_args+=(--ios-device-type "$ios_device_type")
+  fi
+  if [[ -n "$app_id" ]]; then
+    zmr_args+=(--app-id "$app_id")
+  fi
+  if [[ -n "$adb" ]]; then
+    zmr_args+=(--adb "$adb")
+  fi
+  if [[ -n "$android_shim" ]]; then
+    zmr_args+=(--android-shim "$android_shim")
+  fi
+  if [[ -n "$xcrun" ]]; then
+    zmr_args+=(--xcrun "$xcrun")
+  fi
+  if [[ -n "$ios_shim" ]]; then
+    zmr_args+=(--ios-shim "$ios_shim")
+  fi
+
+  command_status=0
+  start_ms="$(python3 -c 'import time; print(int(time.time() * 1000))')"
+  "$ZMR_BIN" "${zmr_args[@]}" || command_status=$?
+  end_ms="$(python3 -c 'import time; print(int(time.time() * 1000))')"
+  duration_ms=$((end_ms - start_ms))
+
+  row="$("$ROOT/scripts/benchmark_result_row.py" \
+    --tool zmr \
+    --run "$run" \
+    --command-status "$command_status" \
+    --duration-ms "$duration_ms" \
+    --trace-dir "$trace_dir")"
+  python3 - "$row" "$device_name" "$platform" "$serial" "$scenario" <<'PY' >> "$RESULTS"
+import json
+import sys
+
+row = json.loads(sys.argv[1])
+row["deviceName"] = sys.argv[2]
+row["platform"] = sys.argv[3]
+row["serial"] = sys.argv[4]
+row["scenario"] = sys.argv[5]
+print(json.dumps(row, separators=(",", ":")))
+PY
+done < "$ROWS"
+
+python3 - "$RESULTS" "$SUMMARY" <<'PY'
+import json
+import statistics
+import sys
+
+results_path = sys.argv[1]
+summary_path = sys.argv[2]
+rows = []
+with open(results_path, "r", encoding="utf-8") as fh:
+    rows = [json.loads(line) for line in fh if line.strip()]
+
+total = len(rows)
+failed = sum(1 for row in rows if row.get("status") != "ok" or row.get("traceStatus") == "failed")
+passed = total - failed
+durations = [int(row.get("durationMs", 0)) for row in rows]
+pass_rate = (passed / total * 100.0) if total else 0.0
+summary = {
+    "totalRuns": total,
+    "passed": passed,
+    "failed": failed,
+    "passRate": round(pass_rate, 2),
+    "meanMs": round(statistics.mean(durations), 2) if durations else 0,
+    "resultsPath": "matrix.jsonl",
+}
+with open(summary_path, "w", encoding="utf-8") as fh:
+    json.dump(summary, fh, separators=(",", ":"))
+    fh.write("\n")
+print(f"matrix: runs={total} passRate={pass_rate:.2f}% failures={failed}")
+PY
+
+gate_failed=0
+python3 - "$SUMMARY" "$MIN_PASS_RATE" "$MAX_FAILURES" <<'PY' || gate_failed=$?
+import json
+import sys
+
+summary_path, min_pass_rate, max_failures = sys.argv[1:4]
+with open(summary_path, "r", encoding="utf-8") as fh:
+    summary = json.load(fh)
+
+failed = False
+if min_pass_rate and summary["passRate"] < float(min_pass_rate):
+    print(f"matrix gate failed: passRate={summary['passRate']:.2f}% < {float(min_pass_rate):.2f}%")
+    failed = True
+if max_failures and summary["failed"] > int(max_failures):
+    print(f"matrix gate failed: failures={summary['failed']} > {int(max_failures)}")
+    failed = True
+raise SystemExit(1 if failed else 0)
+PY
+
+if [[ "$gate_failed" -ne 0 ]]; then
+  exit "$gate_failed"
+fi

package/scripts/ensure-ios-shim-target.rb

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cgi'
+require 'fileutils'
+require 'optparse'
+require 'pathname'
+
+options = {
+  sources: [],
+  deployment_target: '15.0',
+}
+
+OptionParser.new do |parser|
+  parser.banner = 'Usage: ensure-ios-shim-target.rb --project ios/App.xcodeproj --app-target App --test-target AppZMRUITests --scheme AppZMRUITests --bundle-id com.example.app [options]'
+  parser.on('--project PATH', 'Xcode project path') { |value| options[:project] = value }
+  parser.on('--app-target NAME', 'App target under test') { |value| options[:app_target] = value }
+  parser.on('--test-target NAME', 'UI test target to create/update') { |value| options[:test_target] = value }
+  parser.on('--scheme NAME', 'Shared UI test scheme to create/update') { |value| options[:scheme] = value }
+  parser.on('--bundle-id ID', 'App bundle id under test') { |value| options[:bundle_id] = value }
+  parser.on('--test-bundle-id ID', 'UI test bundle id') { |value| options[:test_bundle_id] = value }
+  parser.on('--deployment-target VERSION', 'iOS deployment target') { |value| options[:deployment_target] = value }
+  parser.on('--source PATH', 'Shim source path relative to app root; repeatable') { |value| options[:sources] << value }
+  parser.on('--info-plist PATH', 'Info.plist path relative to app root') { |value| options[:info_plist] = value }
+  parser.on('-h', '--help', 'Show help') do
+    puts parser
+    exit 0
+  end
+end.parse!
+
+required = %i[project app_target test_target scheme bundle_id test_bundle_id info_plist]
+missing = required.select { |key| options[key].to_s.empty? }
+missing << :source if options[:sources].empty?
+unless missing.empty?
+  abort "error: missing required option(s): #{missing.map { |key| "--#{key.to_s.tr('_', '-')}" }.join(', ')}"
+end
+
+begin
+  require 'xcodeproj'
+rescue LoadError
+  abort 'error: missing Ruby gem xcodeproj. Install with `gem install xcodeproj` or add it to the app Gemfile.'
+end
+
+def app_root
+  Pathname.new(Dir.pwd)
+end
+
+def project_dir(project)
+  Pathname.new(File.dirname(File.expand_path(project.path)))
+end
+
+def source_root_relative(project, relative_path)
+  absolute = app_root.join(relative_path).expand_path
+  absolute.relative_path_from(project_dir(project)).to_s
+end
+
+def ensure_file_reference(project, relative_path)
+  xcode_path = source_root_relative(project, relative_path)
+  existing = project.files.find { |file| file.path == xcode_path || file.path == relative_path }
+  if existing
+    existing.path = xcode_path
+    existing.source_tree = 'SOURCE_ROOT'
+    return existing
+  end
+
+  file_ref = project.main_group.new_file(xcode_path)
+  file_ref.source_tree = 'SOURCE_ROOT'
+  file_ref
+end
+
+def ensure_source(target, file_ref)
+  return if target.source_build_phase.files_references.include?(file_ref)
+
+  target.source_build_phase.add_file_reference(file_ref, true)
+end
+
+def ensure_dependency(target, dependency)
+  return if target.dependencies.any? { |candidate| candidate.target == dependency }
+
+  target.add_dependency(dependency)
+end
+
+def product_name(target)
+  target.product_reference&.display_name || "#{target.name}.app"
+end
+
+def buildable_reference(target, container)
+  <<~XML
+    <BuildableReference
+       BuildableIdentifier = "primary"
+       BlueprintIdentifier = "#{CGI.escapeHTML(target.uuid)}"
+       BuildableName = "#{CGI.escapeHTML(product_name(target))}"
+       BlueprintName = "#{CGI.escapeHTML(target.name)}"
+       ReferencedContainer = "#{CGI.escapeHTML(container)}">
+    </BuildableReference>
+  XML
+end
+
+def write_scheme(project, app_target, test_target, scheme_name)
+  scheme_dir = File.join(project.path, 'xcshareddata/xcschemes')
+  FileUtils.mkdir_p(scheme_dir)
+  scheme_path = File.join(scheme_dir, "#{scheme_name}.xcscheme")
+  container = "container:#{File.basename(project.path)}"
+  app_ref = buildable_reference(app_target, container)
+  test_ref = buildable_reference(test_target, container)
+
+  xml = <<~XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <Scheme
+       LastUpgradeVersion = "1600"
+       version = "1.7">
+       <BuildAction
+          parallelizeBuildables = "YES"
+          buildImplicitDependencies = "YES">
+          <BuildActionEntries>
+             <BuildActionEntry
+                buildForTesting = "YES"
+                buildForRunning = "YES"
+                buildForProfiling = "YES"
+                buildForArchiving = "YES"
+                buildForAnalyzing = "YES">
+    #{app_ref.rstrip}
+             </BuildActionEntry>
+             <BuildActionEntry
+                buildForTesting = "YES"
+                buildForRunning = "NO"
+                buildForProfiling = "NO"
+                buildForArchiving = "NO"
+                buildForAnalyzing = "YES">
+    #{test_ref.rstrip}
+             </BuildActionEntry>
+          </BuildActionEntries>
+       </BuildAction>
+       <TestAction
+          buildConfiguration = "Debug"
+          selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+          selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+          shouldUseLaunchSchemeArgsEnv = "YES">
+          <Testables>
+             <TestableReference skipped = "NO">
+    #{test_ref.rstrip}
+                <SelectedTests>
+                   <Test Identifier = "ZMRShimUITestCase/testRunZMRCommand">
+                   </Test>
+                </SelectedTests>
+             </TestableReference>
+          </Testables>
+          <MacroExpansion>
+    #{app_ref.rstrip}
+          </MacroExpansion>
+          <EnvironmentVariables>
+             <EnvironmentVariable key = "ZMR_SHIM_REQUEST_FILE" value = "$(ZMR_SHIM_REQUEST_FILE)" isEnabled = "YES">
+             </EnvironmentVariable>
+             <EnvironmentVariable key = "ZMR_SHIM_RESPONSE_FILE" value = "$(ZMR_SHIM_RESPONSE_FILE)" isEnabled = "YES">
+             </EnvironmentVariable>
+             <EnvironmentVariable key = "ZMR_SHIM_MODE" value = "$(ZMR_SHIM_MODE)" isEnabled = "YES">
+             </EnvironmentVariable>
+             <EnvironmentVariable key = "ZMR_SHIM_SERVER_DIR" value = "$(ZMR_SHIM_SERVER_DIR)" isEnabled = "YES">
+             </EnvironmentVariable>
+             <EnvironmentVariable key = "ZMR_APP_BUNDLE_ID" value = "$(ZMR_APP_BUNDLE_ID)" isEnabled = "YES">
+             </EnvironmentVariable>
+          </EnvironmentVariables>
+       </TestAction>
+       <LaunchAction
+          buildConfiguration = "Debug"
+          selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+          selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+          launchStyle = "0"
+          useCustomWorkingDirectory = "NO"
+          ignoresPersistentStateOnLaunch = "NO"
+          debugDocumentVersioning = "YES"
+          debugServiceExtension = "internal"
+          allowLocationSimulation = "YES">
+          <BuildableProductRunnable runnableDebuggingMode = "0">
+    #{app_ref.rstrip}
+          </BuildableProductRunnable>
+       </LaunchAction>
+       <ProfileAction
+          buildConfiguration = "Release"
+          shouldUseLaunchSchemeArgsEnv = "YES"
+          savedToolIdentifier = ""
+          useCustomWorkingDirectory = "NO"
+          debugDocumentVersioning = "YES">
+          <BuildableProductRunnable runnableDebuggingMode = "0">
+    #{app_ref.rstrip}
+          </BuildableProductRunnable>
+       </ProfileAction>
+       <AnalyzeAction buildConfiguration = "Debug">
+       </AnalyzeAction>
+       <ArchiveAction
+          buildConfiguration = "Release"
+          revealArchiveInOrganizer = "YES">
+       </ArchiveAction>
+    </Scheme>
+  XML
+
+  File.write(scheme_path, xml)
+end
+
+project_path = File.expand_path(options[:project], Dir.pwd)
+project = Xcodeproj::Project.open(project_path)
+app_target = project.targets.find { |target| target.name == options[:app_target] }
+abort "error: missing app target #{options[:app_target]}" unless app_target
+
+test_target = project.targets.find { |target| target.name == options[:test_target] }
+test_target ||= project.new_target(:ui_test_bundle, options[:test_target], :ios, options[:deployment_target])
+
+ensure_dependency(test_target, app_target)
+
+options[:sources].each do |source_path|
+  abort "error: missing #{source_path}; run install-ios-shim first" unless File.exist?(app_root.join(source_path))
+
+  ensure_source(test_target, ensure_file_reference(project, source_path))
+end
+
+info_plist = source_root_relative(project, options[:info_plist])
+team = app_target.build_configurations.map { |config| config.build_settings['DEVELOPMENT_TEAM'] }.find { |value| !value.to_s.empty? }
+
+test_target.build_configurations.each do |configuration|
+  settings = configuration.build_settings
+  settings['CODE_SIGN_STYLE'] = 'Automatic'
+  settings['DEVELOPMENT_TEAM'] = team if team
+  settings['GENERATE_INFOPLIST_FILE'] = 'NO'
+  settings['INFOPLIST_FILE'] = info_plist
+  settings['IPHONEOS_DEPLOYMENT_TARGET'] = options[:deployment_target]
+  settings['PRODUCT_BUNDLE_IDENTIFIER'] = options[:test_bundle_id]
+  settings['PRODUCT_MODULE_NAME'] = '$(TARGET_NAME)'
+  settings['PRODUCT_NAME'] = '$(TARGET_NAME)'
+  settings['SWIFT_VERSION'] = '5.0'
+  settings['TARGETED_DEVICE_FAMILY'] = '1,2'
+  settings['TEST_TARGET_NAME'] = options[:app_target]
+end
+
+project.save
+write_scheme(project, app_target, test_target, options[:scheme])
+
+puts "ensured #{options[:test_target]} and #{options[:scheme]}.xcscheme"