@sun-asterisk/sungen 3.2.24-beta.6 → 3.2.24

package/src/orchestrator/templates/wdio.conf.ts

@@ -178,6 +178,61 @@ function resolveLocaleCaps(): Record<string, unknown> {
 }
 const localeCaps = resolveLocaleCaps();
 
+// ── Connectivity self-heal (#615) ───────────────────────────────────────────
+// The connectivity/location steps mutate DEVICE state (airplane, wifi, data, GPS). A run that
+// aborts mid-toggle — e.g. an Appium session timeout during an airplane round-trip — leaves the
+// device offline as PERSISTENT state, so every later launch fails with the app's network error
+// and the next run dies at cold start. Restore the baseline around the run via host-side adb:
+// it works even when no Appium session survives (a spec-level after() cannot — the session is
+// exactly what died). Android-only (the mutating steps are Android-only), idempotent (on/on/on
+// is the baseline every suite assumes; offline scenarios set their own state mid-test), and
+// best-effort per command (a device lacking one command just skips that line).
+function restoreConnectivity(hook: string): void {
+  if (!RUN_ANDROID) return;
+  // Appium finds adb via ANDROID_HOME — PATH may not carry it (fresh CI runner), which would
+  // make every heal command fail silently. Resolve the same way Appium does, fall back to PATH.
+  const adbBin = process.env.ANDROID_HOME ? path.join(process.env.ANDROID_HOME, 'platform-tools', 'adb') : 'adb';
+  const adb = `"${adbBin}" -s ${process.env.ANDROID_UDID || '__ANDROID_UDID__'} shell`;
+  // stderr ignored: with a detached device the reads would otherwise spray raw adb errors on every run.
+  const sh = (cmd: string) => execSync(`${adb} ${cmd}`, { timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  // Detect-first: read each state and only touch what is actually wedged, so a healthy run
+  // costs four quick reads, mutates nothing, and logs nothing. Each fix lists every command
+  // variant (emulator `svc`, real-device `cmd`, API<30 fallbacks) — all best-effort, same
+  // direction, idempotent, so running the inapplicable ones is harmless.
+  let touched = false;
+  const heal = (read: string, wedged: string, fixes: string[]) => {
+    try {
+      if (sh(read) !== wedged) return;
+      for (const fix of fixes) { try { sh(fix); } catch { /* variant not on this API — fine */ } }
+      touched = true;
+    } catch { /* unreadable state (device gone / key absent) — leave untouched */ }
+  };
+  heal('settings get global airplane_mode_on', '1', [
+    'cmd connectivity airplane-mode disable',                       // API 30+
+    'settings put global airplane_mode_on 0',                       // API<30 wedge (settings+broadcast)
+    'am broadcast -a android.intent.action.AIRPLANE_MODE --ez state false',
+  ]);
+  heal('settings get global wifi_on', '0', [
+    'svc wifi enable',                                              // emulator flavor
+    'cmd -w wifi set-wifi-enabled enabled',                         // real-device flavor (svc can no-op silently)
+  ]);
+  heal('settings get global mobile_data', '0', [
+    'svc data enable',
+    'cmd phone data enable',
+  ]);
+  heal('cmd location is-location-enabled', 'false', ['cmd location set-location-enabled true']);
+  if (!touched) return;
+  console.log(`[sungen] connectivity self-heal (${hook}): device was offline — a previous run likely aborted mid-toggle. Baseline restored (airplane off, wifi/data/location on).`);
+  // Radios re-associate asynchronously (emulator wifi can take 10-30s) — wait for REAL IP
+  // connectivity before the session starts, or the app's first cold start still lands on its
+  // network-error dialog and the auth/first assert fails despite the heal.
+  for (let i = 0; i < 10; i++) {
+    try { execSync(`${adb} ping -c 1 -W 2 8.8.8.8`, { stdio: 'ignore', timeout: 8000 }); return; } catch { /* not yet */ }
+    try { execSync(`${adb} sleep 2`, { stdio: 'ignore', timeout: 8000 }); } catch { /* device gone — stop waiting */ return; }
+  }
+  console.log('[sungen] connectivity self-heal: no ICMP reply within ~30s — continuing (fine if this network blocks ping; otherwise the device may need a cold boot).');
+}
+
 export const config: WebdriverIO.Config = {
   runner: 'local',
   tsConfigPath: './tsconfig.json',
@@ -192,7 +247,10 @@ export const config: WebdriverIO.Config = {
   // Global auto-wait for $/$$ matchers (toBeDisplayed, click, …). Default is 3s, too short for a
   // heavy app's cold (re)launch — each scenario terminates+activates its app, so the first
   // find/click must wait out the splash/first-frame. 20s keeps slow native/Flutter apps green.
-  waitforTimeout: 20000,
+  // 30s (not the classic 20s): on a Compose app with looping in-app animations the accessibility
+  // manager can starve for 10s+ per query ("Timed out waiting for the root AccessibilityNodeInfo",
+  // observed live) — a 20s budget turns that latency into flaky not-found failures.
+  waitforTimeout: 30000,
 
   // Capability set(s) selected by MOBILE_PLATFORM (android | ios | both). Each cap carries its OWN
   // `specs` (per-OS routing): the Android cap runs android + mobile specs, the iOS cap runs ios +
@@ -217,6 +275,14 @@ export const config: WebdriverIO.Config = {
             'appium:noReset': true,
             'appium:autoGrantPermissions': true,
             'appium:newCommandTimeout': 300,
+            // Compose/animated UIs (a looping promo animation is enough) never report accessibility-idle,
+            // so every find first waits out UiAutomator2's full idle timeout — 10000ms by default. 2s keeps
+            // interactions responsive while still absorbing screen transitions. NOTE: milliseconds — the
+            // same-named XCUITest cap below is in seconds; the two drivers define the knob differently.
+            'appium:settings[waitForIdleTimeout]': 2000,
+            // Disable SYSTEM animation scales for the session — trims accessibility-tree churn so
+            // queries stall less on animation-heavy apps (in-app Compose animations still run).
+            'appium:disableWindowAnimation': true,
             // i18n: when SUNGEN_ENV/SUNGEN_LOCALE is a locale code, this overrides noReset→false and
             // adds appium:language/appium:locale so the app boots in that locale. Empty otherwise.
             ...localeCaps,
@@ -275,7 +341,23 @@ export const config: WebdriverIO.Config = {
   reporters: ['spec', [PwShapeReporter, {}]],
 
   // Auto-start a local Appium server on :4723 (base path '/')
-  services: ['appium'],
+  // Appium server options — security-gated features, each opt-in via .env.appium:
+  //   APPIUM_ALLOW_ADB_SHELL=1            → --allow-insecure uiautomator2:adb_shell
+  //     (raw shell access — device-level oracles like device-sqlite's run-as fallback)
+  //   APPIUM_CHROMEDRIVER_AUTODOWNLOAD=1  → --allow-insecure uiautomator2:chromedriver_autodownload
+  //     (hybrid WebView: downloads the chromedriver matching the device's WebView at session start —
+  //      without it, `switch to [X] frame` fails with "No Chromedriver found that can automate Chrome N")
+  // Both stay OFF by default (see docs/spec/security-and-telemetry-roadmap.md).
+  services: [
+    ['appium', (() => {
+      const feats: string[] = [];
+      if (process.env.APPIUM_ALLOW_ADB_SHELL) feats.push('uiautomator2:adb_shell');
+      if (process.env.APPIUM_CHROMEDRIVER_AUTODOWNLOAD) feats.push('uiautomator2:chromedriver_autodownload');
+      // NOTE: pass a comma-joined STRING — @wdio/appium-service JSON.stringifies arrays, which the
+      // appium server then reads as a JSON literal and the features silently never register.
+      return feats.length ? { args: { allowInsecure: feats.join(',') } } : {};
+    })()],
+  ],
   port: 4723,
   path: '/',
 
@@ -291,12 +373,27 @@ export const config: WebdriverIO.Config = {
     retries: 1,
   },
 
+  // expect-webdriverio's default assertion budget (~2s wait / 100ms interval) is tuned for
+  // sub-second finds. On an accessibility tree churned by looping in-app animations (a rotating
+  // promo carousel is enough) a single server-side find can take 5-15s, so every toBeDisplayed()
+  // would expire before its first query even returns — align the budget with waitforTimeout.
+  before: async () => {
+    const { setOptions } = await import('expect-webdriverio');
+    setOptions({ wait: 20000, interval: 500 });
+  },
+
+  // Connectivity self-heal (#615): onPrepare heals a device wedged by a previous KILLED run
+  // (its onComplete never fired) before the session starts; onComplete restores after this run,
+  // pass or fail. Both run in the launcher process, so they fire even when the worker/session died.
+  onPrepare: () => restoreConnectivity('onPrepare'),
+  onComplete: () => restoreConnectivity('onComplete'),
+
   // iOS + locale: XCUITest's `noReset:false` does NOT actually clear the app's data container
   // (verified live 2026-06-11) — a Flutter app that persisted its language on a previous launch keeps
   // it and ignores the new device locale, so the i18n run asserts the wrong language. Wipe the app
   // data via simctl BEFORE the session so first-launch locale detection re-runs. Android needs no
   // hook (its noReset:false reset works natively).
-  beforeSession: async (_config, capabilities) => {
+  beforeSession: async (_config, capabilities, specs) => {
     if (Object.keys(localeCaps).length === 0) return; // not a locale run
     const caps = capabilities as Record<string, unknown>;
     if (String(caps['platformName'] || '').toLowerCase() !== 'ios') return;

package/src/utils/selector-types.ts

@@ -20,6 +20,7 @@ export const VALID_SELECTOR_TYPES = [
   'xpath',               // cross-platform, last resort
   'android-uiautomator', // Android only — UiSelector expressions
   'ios-predicate',       // iOS only — NSPredicate strings
+  'css',                 // hybrid WebView only — CSS inside a WEBVIEW context (after `switch to [X] frame`)
 ] as const;
 
 export type SelectorType = (typeof VALID_SELECTOR_TYPES)[number];