@algorandfoundation/react-native-passkey-autofill 1.0.0-canary.2 → 1.0.0-canary.21

package/e2e/driver/selectors.ts

@@ -0,0 +1,103 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { Driver } from "./session";
+import { PLATFORM } from "./capabilities";
+
+/**
+ * Returns a locator string matching an element by its React Native
+ * `testID`. On iOS (XCUITest) `testID` is surfaced as the accessibility
+ * id, so the `~testID` tilde-selector works directly. On Android
+ * (UiAutomator2) RN maps `testID` to the view's `resource-id` instead,
+ * so we build a UiSelector querying `resourceId(...)`.
+ */
+export const byTestId = (testID: string): string => {
+  if (PLATFORM === "ios") return `~${testID}`;
+  // Android: check both resource-id (used by RN) and content-desc (used by
+  // native activities). We also match the short :id/name suffix.
+  return `//*[@resource-id='${testID}' or @content-desc='${testID}' or contains(@resource-id, ':id/${testID}') or @text='${testID}']`;
+};
+
+/**
+ * Platform-neutral selector for native system dialogs triggered by
+ * WebAuthn (passkey prompts, biometrics, save-password sheets).
+ */
+export const systemDialogButton = (label: string): string => {
+  if (PLATFORM === "ios") {
+    // iOS system alerts: CONTAINS match survives suffixes like "Create Passkey".
+    return `-ios predicate string:type == 'XCUIElementTypeButton' AND name CONTAINS[c] '${label}'`;
+  }
+  // Android: case-insensitive substring match — intentionally *contains*,
+  // not exact. We check both text and content-desc using XPath.
+  const l = label.toLowerCase();
+  const u = label.toUpperCase();
+  return `//*[contains(@text, '${label}') or contains(@text, '${l}') or contains(@text, '${u}') or contains(@content-desc, '${label}') or contains(@content-desc, '${l}') or contains(@content-desc, '${u}')]`;
+};
+
+/**
+ * Waits for an element to exist and be displayed, then taps it.
+ */
+export async function tap(driver: Driver, selector: string, timeoutMs = 15_000): Promise<void> {
+  const el = await driver.$(selector);
+  await el.waitForDisplayed({ timeout: timeoutMs });
+  await el.click();
+}
+
+/**
+ * Attempts to dismiss any OS-level passkey/biometric dialog by pressing
+ * the affirmative button. No-op if the dialog is not present.
+ */
+export async function confirmSystemPrompt(
+  driver: Driver,
+  labels: string[] = ["Continue", "Allow", "Save", "Use Passkey", "Sign In"],
+  timeoutMs = 10_000,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    for (const label of labels) {
+      const el = await driver.$(systemDialogButton(label));
+      if (await el.isExisting().catch(() => false)) {
+        await el.click().catch(() => undefined);
+        return true;
+      }
+    }
+    await driver.pause(500);
+  }
+  // eslint-disable-next-line no-console
+  console.log(
+    `[e2e] confirmSystemPrompt: timed out waiting for labels [${labels.join(", ")}]. Visible labels: ${await getVisibleLabels(driver)}`,
+  );
+  return false;
+}
+
+async function getVisibleLabels(driver: Driver): Promise<string[]> {
+  try {
+    const src = await driver.getPageSource();
+    const rx = /(?:text|content-desc)="([^"]+)"/g;
+    const labels = new Set<string>();
+    let m;
+    while ((m = rx.exec(src))) {
+      const l = m[1].trim();
+      if (l && l.length < 50) labels.add(l);
+    }
+    return [...labels];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Capture a screenshot for review.
+ */
+export async function takeScreenshot(driver: Driver, name: string): Promise<void> {
+  try {
+    const b64 = await driver.takeScreenshot();
+    const filename = `screenshot-${Date.now()}-${name.replace(/[^a-z0-9]/gi, "-").toLowerCase()}.png`;
+    const fullPath = path.join(process.cwd(), filename);
+    fs.writeFileSync(fullPath, Buffer.from(b64, "base64"));
+    // eslint-disable-next-line no-console
+    console.log(`[e2e] screenshot saved to ${filename}`);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn(`[e2e] failed to take screenshot: ${e}`);
+  }
+}

package/e2e/driver/session.ts

@@ -0,0 +1,25 @@
+import { remote, type Browser } from "webdriverio";
+
+import {
+  APPIUM_HOST,
+  APPIUM_PORT,
+  PLATFORM,
+  capabilitiesForPlatform,
+  type Platform,
+} from "./capabilities";
+
+export type Driver = Browser;
+
+/**
+ * Creates a WebdriverIO session against a locally running Appium server.
+ * The caller is responsible for tearing the session down with `driver.deleteSession()`.
+ */
+export async function createDriver(platform: Platform = PLATFORM): Promise<Driver> {
+  return remote({
+    hostname: APPIUM_HOST,
+    port: APPIUM_PORT,
+    path: "/",
+    logLevel: (process.env.WDIO_LOG_LEVEL as "error" | "warn" | "info" | "debug") ?? "warn",
+    capabilities: capabilitiesForPlatform(platform),
+  });
+}

package/e2e/jest.config.ts

@@ -0,0 +1,20 @@
+import type { Config } from "jest";
+
+/**
+ * Jest configuration for Appium / WebdriverIO end-to-end tests.
+ *
+ * Each test file bootstraps its own WebdriverIO `remote()` session via
+ * `driver/session.ts`, so we run a single worker and give each spec a
+ * generous timeout to account for native app cold starts + WebAuthn UI.
+ */
+const config: Config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  rootDir: ".",
+  testMatch: ["<rootDir>/tests/**/*.test.ts"],
+  testTimeout: 5 * 60 * 1000,
+  maxWorkers: 1,
+  verbose: true,
+};
+
+export default config;

package/e2e/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@algorandfoundation/react-native-passkey-autofill-e2e",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Appium + WebdriverIO + Jest end-to-end tests for the Passkey AutoFill example app.",
+  "scripts": {
+    "test": "node --experimental-vm-modules ../node_modules/jest/bin/jest.js --config jest.config.ts",
+    "test:android": "E2E_PLATFORM=android node --experimental-vm-modules ../node_modules/jest/bin/jest.js --config jest.config.ts",
+    "test:ios": "E2E_PLATFORM=ios node --experimental-vm-modules ../node_modules/jest/bin/jest.js --config jest.config.ts"
+  }
+}

package/e2e/tests/passkey.test.ts

@@ -0,0 +1,190 @@
+import { createDriver, type Driver } from "../driver/session";
+import {
+  byTestId,
+  confirmSystemPrompt,
+  tap,
+  takeScreenshot,
+  systemDialogButton,
+} from "../driver/selectors";
+import { PLATFORM, ANDROID_PACKAGE } from "../driver/capabilities";
+import {
+  ensureBiometricEnrolled,
+  pumpFingerprintUntil,
+  currentPackage,
+  currentActivity,
+} from "../driver/fingerprint";
+import { ensureAndroidCredentialProviderEnabled } from "../driver/credentialProvider";
+
+/**
+ * End-to-end coverage for the Passkey AutoFill example app.
+ *
+ * The flow mirrors what the example does at runtime:
+ *   1. Mint a local XHD Ed25519 key (prerequisite for `handleCreatePasskey`).
+ *   2. Create a passkey via `https://debug.liquidauth.com/attestation/*`.
+ *   3. Re-use the passkey via `https://debug.liquidauth.com/assertion/*`.
+ *
+ * System-level WebAuthn prompts (e.g. "Continue", Face ID/Touch ID) are
+ * auto-confirmed where possible; on the Android emulator the
+ * `autoGrantPermissions` capability handles runtime permissions.
+ */
+describe("Passkey AutoFill example", () => {
+  let driver: Driver;
+
+  beforeAll(async () => {
+    // eslint-disable-next-line no-console
+    console.log("[e2e] beforeAll: creating driver...");
+    driver = await createDriver();
+    // eslint-disable-next-line no-console
+    console.log("[e2e] beforeAll: driver created");
+
+    if (PLATFORM === "android") {
+      // eslint-disable-next-line no-console
+      console.log("[e2e] beforeAll: ensuring credential provider enabled...");
+      // Register our passkey service as the system's Credential Manager
+      // provider. A fresh AVD has no providers enabled, so Credential
+      // Manager would never route BeginCreate*/BeginGet* to our service
+      // and `provider-status` would stay `inactive` (observed in CI).
+      const providerRegistered = await ensureAndroidCredentialProviderEnabled();
+      // eslint-disable-next-line no-console
+      console.log("[e2e] beforeAll: android credential provider registered:", providerRegistered);
+      if (!providerRegistered) {
+        throw new Error(
+          "[e2e] Android Credential Provider registration failed — cannot exercise passkey flow",
+        );
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log("[e2e] beforeAll: ensuring biometrics enrolled...");
+    // Enroll biometrics so the system prompts can be satisfied
+    // (Touch ID/Face ID on iOS simulator, Fingerprint on Android emulator).
+    const enrolled = await ensureBiometricEnrolled(driver);
+    // eslint-disable-next-line no-console
+    console.log(`[e2e] beforeAll: ${PLATFORM} biometric enrolled:`, enrolled);
+    if (!enrolled) {
+      throw new Error(
+        `[e2e] ${PLATFORM} biometric enrollment failed — cannot exercise passkey flow. ` +
+          (PLATFORM === "android"
+            ? "See [e2e:fingerprint] logs for the Settings wizard labels observed on the AVD."
+            : ""),
+      );
+    }
+    // eslint-disable-next-line no-console
+    console.log("[e2e] beforeAll: finished");
+  }, 180_000);
+
+  afterAll(async () => {
+    if (driver) {
+      await driver.deleteSession().catch(() => undefined);
+    }
+  });
+
+  it("launches the example app and shows the header", async () => {
+    const header = await driver.$(
+      PLATFORM === "ios"
+        ? `-ios predicate string:name == 'Passkey AutoFill Example'`
+        : `android=new UiSelector().text("Passkey AutoFill Example")`,
+    );
+    await header.waitForDisplayed({ timeout: 30_000 });
+    expect(await header.isDisplayed()).toBe(true);
+    await driver.pause(200);
+    await takeScreenshot(driver, "app-start");
+  });
+
+  /**
+   * Smoke-read the provider status banner before the passkey flow runs.
+   *
+   * The native check is best-effort: on Android 12+ the underlying
+   * `credential_service` Secure key is `@hide`-restricted and throws
+   * `SecurityException` when read from a regular app, so the status can
+   * legitimately report `unknown` or `inactive` *before* the system has
+   * routed the first `BeginCreateCredentialRequest` to our service (which
+   * stamps MMKV and flips the status to `active`). That authoritative
+   * post-stamp assertion lives in the passkey creation test below; this
+   * one only surfaces the initial reading for log context.
+   */
+  it("surfaces the initial provider status", async () => {
+    const status = await driver.$(byTestId("provider-status"));
+    await status.waitForDisplayed({ timeout: 15_000 });
+    const text = (await status.getText()).toLowerCase();
+    // eslint-disable-next-line no-console
+    console.log("[e2e] initial provider status:", text);
+    expect(["active", "inactive", "unknown"].some((s) => text.includes(s))).toBe(true);
+  });
+
+  it("creates an XHD Ed25519 key", async () => {
+    await tap(driver, byTestId("create-ed25519-key-button"));
+    // Wait for the alert with the mnemonic to show.
+    await driver.$(systemDialogButton("XHD Ed25519 Key created")).waitForExist({ timeout: 10_000 });
+    await driver.pause(200);
+    await takeScreenshot(driver, "xhd-key-created-alert");
+    await confirmSystemPrompt(driver, ["OK", "Okay", "Dismiss"]);
+  });
+
+  /**
+   * Predicate: is the example app currently in the foreground? Used as
+   * the termination signal when we spam `adb emu finger touch` — as
+   * soon as Credential Manager closes its bottom-sheet and control
+   * returns to the app, we stop touching.
+   */
+  const appInForeground = async (): Promise<boolean> => {
+    const pkg = await currentPackage();
+    const act = await currentActivity();
+    if (pkg === ANDROID_PACKAGE) {
+      // Only return true if we are in the main activity. If a library activity
+      // like CreatePasskeyActivity is on top, we want to keep pumping.
+      return act.includes("MainActivity");
+    }
+    const el = await driver.$(byTestId("passkey-action-button"));
+    return el.isDisplayed().catch(() => false);
+  };
+
+  it("creates and then uses a passkey against debug.liquidauth.com", async () => {
+    // `beforeAll` has already thrown on Android if the Credential
+    // Provider wasn't registered or no fingerprint could be enrolled,
+    // so reaching this point means the biometric sheet can be satisfied
+    // deterministically via `adb emu finger touch`.
+    // Create passkey. The system first shows a consent screen ("Continue"
+    // / "Create"), then the biometric sheet. We dismiss the consent via
+    // `confirmSystemPrompt`, then feed simulated finger touches via
+    // `adb emu finger touch` until the sheet closes and the app returns
+    // to the foreground.
+    await tap(driver, byTestId("passkey-action-button"));
+    // pumpFingerprintUntil now handles both system prompts (Continue/Create)
+    // and our own intermediate activities (CreatePasskeyActivity) by
+    // repeatedly clicking affirmative buttons until back in the main app.
+    await pumpFingerprintUntil(driver, appInForeground, { timeoutMs: 45_000 });
+    // Wait for the app-level success alert to appear.
+    await driver.$(systemDialogButton("Passkey created")).waitForExist({ timeout: 10_000 });
+    await confirmSystemPrompt(driver, ["OK", "Okay", "Dismiss", "Got it"]);
+    // Allow time for the alert to clear before the final screenshot.
+    await driver.pause(500);
+    await takeScreenshot(driver, "passkey-create-success");
+
+    // After the first create, the provider stamp must flip the status to
+    // "active" — this is the authoritative assertion that *this* app
+    // served the system prompt (not a different installed provider).
+    const status = await driver.$(byTestId("provider-status"));
+    await status.waitForDisplayed({ timeout: 15_000 });
+    const deadline = Date.now() + 10_000;
+    let text = "";
+    while (Date.now() < deadline) {
+      text = (await status.getText()).toLowerCase();
+      if (text.includes("active") && !text.includes("inactive")) break;
+      await driver.pause(500);
+    }
+    expect(text).toMatch(/active/);
+    expect(text).not.toMatch(/inactive/);
+
+    // The button title flips to "Use Passkey" once one exists; re-tap it
+    // to exercise the assertion flow.
+    await tap(driver, byTestId("passkey-action-button"));
+    await pumpFingerprintUntil(driver, appInForeground, { timeoutMs: 45_000 });
+    await confirmSystemPrompt(driver, ["OK", "Okay", "Dismiss", "Got it"]);
+  });
+
+  it("clears all passkeys and keys", async () => {
+    await tap(driver, byTestId("clear-passkeys-button"));
+    await confirmSystemPrompt(driver, ["OK", "Okay", "Dismiss"]);
+  });
+});

package/e2e/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node", "jest", "@wdio/globals/types"],
+    "baseUrl": ".",
+    "outDir": "./dist"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/ios/AutofillCredentialProvider/BiometricRequirement.swift

@@ -0,0 +1,34 @@
+import Foundation
+import LocalAuthentication
+
+/// Authentication requirement for passkey operations, configured at build time via the
+/// `biometricRequirement` config-plugin prop and read from the extension Info.plist.
+/// iOS has no weak-biometric concept, so both relaxed levels allow the device passcode.
+enum BiometricRequirement: String {
+  case strong
+  case strongOrCredential
+  case weakOrCredential
+
+  private static let infoDictionaryKey = "ReactNativePasskeyAutofillBiometricRequirement"
+
+  static let current: BiometricRequirement = {
+    guard
+      let raw = Bundle.main.object(forInfoDictionaryKey: infoDictionaryKey) as? String,
+      let parsed = BiometricRequirement(rawValue: raw)
+    else {
+      return .strongOrCredential
+    }
+    return parsed
+  }()
+
+  /// `.deviceOwnerAuthenticationWithBiometrics` rejects the passcode; `.deviceOwnerAuthentication`
+  /// allows biometrics or passcode.
+  var laPolicy: LAPolicy {
+    switch self {
+    case .strong:
+      return .deviceOwnerAuthenticationWithBiometrics
+    case .strongOrCredential, .weakOrCredential:
+      return .deviceOwnerAuthentication
+    }
+  }
+}