@swipt/cli 0.1.0-nightly.47 → 0.1.0-nightly.49

package/sideload/trust.js

@@ -1,235 +1,249 @@
-const [id] = args;
+const [id, mode, waitsForUnlock] = args;
+const name = "Swipt";
 const settings = "com.apple.Preferences";
+const springboard = "com.apple.springboard";
 const developerPattern =
   /(?:Apple Development|iPhone Developer): .+?\([A-Z0-9]{10}\)/;
-const tapTimeoutMs = 3_000;
 
-const sheet = async () => {
-  const screen = await accessibility.snapshot({ scope: "screen" });
-  return screen.find({ role: "sheet" });
-};
+const sheet = (timeoutMs) =>
+  accessibility.find(
+    { app: springboard, role: "sheet", label: /./ },
+    { timeoutMs, poll: true },
+  );
 
-const alertPresentMs = 600;
+const inSettings = (selector, timeoutMs) =>
+  accessibility.find({ app: settings, ...selector }, { timeoutMs, poll: true });
 
-async function dismiss(alert, buttons, index) {
-  await sleep(alertPresentMs);
-  for (let attempt = 0; attempt < 5; attempt++) {
-    await input.tap(buttons[index].point);
-    await sleep(alertPresentMs);
-    const shown = await sheet();
-    if (shown === null || shown.label !== alert.label) {
-      return;
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+async function tap(element) {
+  try {
+    await accessibility.tap(element, { timeoutMs: 0 });
+  } catch (error) {
+    if (error.name !== "TimeoutError") {
+      throw error;
     }
   }
-  throw new Error(`the alert stays: ${alert.label}`);
 }
 
-async function allowPrompts(name, waitMs) {
-  const until = Date.now() + waitMs;
+async function dismiss(alert, index) {
+  const until = Date.now() + 10_000;
+  let absent = 0;
   do {
-    const alert = await sheet();
-    const buttons = alert?.findAll({ role: "button" }) ?? [];
-    if (buttons.length === 2 && alert.label?.includes(name)) {
-      await dismiss(alert, buttons, 1);
+    const shown = await sheet();
+    if (shown === null) {
+      absent += 1;
+      if (absent === 2) {
+        return;
+      }
+      continue;
+    }
+    if (shown.label !== alert.label) {
       return;
     }
-    await sleep(300);
+    absent = 0;
+    await tap(shown.findAll({ role: "button" })[index]);
   } while (Date.now() < until);
+  throw new Error(`the alert stays: ${alert.label}`);
 }
 
-async function launch(name) {
+async function answerPrompt() {
+  const alert = await sheet();
+  const buttons = alert?.findAll({ role: "button" }) ?? [];
+  if (alert?.label?.includes(name) && [2, 3].includes(buttons.length)) {
+    console.debug("answering a permission alert");
+    // The location alert shows an icon and lists Allow Once first; the cellular
+    // data alert of China mainland devices shows none and lists Wi-Fi and
+    // cellular first (iPhone18,2, iOS 27.2 24B115).
+    const location = alert.findAll({ role: "image" }).length > 0;
+    await dismiss(alert, buttons.length === 2 || location ? 1 : 0);
+  }
+  return alert !== null;
+}
+
+async function launch() {
   try {
+    console.debug(`launching ${name}`);
     await device.launchApplication(id, { restart: true });
-    await allowPrompts(name, 3_000);
     return null;
   } catch (error) {
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const alert = await sheet();
+    const until = Date.now() + 5_000;
+    do {
+      const alert = await sheet(Math.max(until - Date.now(), 0));
       const buttons = alert?.findAll({ role: "button" }) ?? [];
       if (buttons.length === 1) {
         const developer = alert
           .findAll({ role: "text" })
           .map((text) => developerPattern.exec(text.label ?? "")?.[0])
           .find((found) => found !== undefined);
-        await dismiss(alert, buttons, 0);
+        await dismiss(alert, 0);
         if (developer === undefined) {
           throw new Error(`the alert names no developer: ${alert.label}`);
         }
         return developer;
       }
-      await sleep(300);
-    }
+    } while (Date.now() < until);
     throw error;
   }
 }
 
-async function findScrolling(selector, bounds) {
-  for (let attempt = 0; attempt < 12; attempt++) {
-    const found = await accessibility.find(
-      { app: settings, ...selector },
-      { timeoutMs: 1_500, poll: true },
-    );
-    if (found !== null && !found.partial && !found.offScreen) {
-      return found;
-    }
-    const distance = found === null ? 0.5 : 0.25;
-    await input.swipe(
-      [bounds.width * 0.6, bounds.height * (0.3 + distance)],
-      [bounds.width * 0.6, bounds.height * 0.3],
-      { durationMs: 300 },
-    );
-    await sleep(500);
+function developerRows(list, developer) {
+  if (list.findAll({ role: "button", identifier: "VPN" }).length === 0) {
+    return [];
   }
-  throw new Error(`Settings did not show ${JSON.stringify(selector)}`);
+  const elsewhere = new Set(
+    list
+      .findAll({
+        role: "button",
+        within: {
+          identifier: "com.apple.settings.sidebar.collectionView",
+        },
+      })
+      .concat(
+        list.findAll({
+          role: "button",
+          within: { role: /^(navigationBar|searchField)$/ },
+        }),
+      )
+      .map((row) => row.identifier),
+  );
+  return list
+    .findAll({ role: "button" })
+    .filter(
+      (row) =>
+        row.identifier !== undefined &&
+        row.identifier !== "BackButton" &&
+        row.identifier !== "VPN" &&
+        !row.identifier.startsWith("com.apple.settings.") &&
+        row.identifier !== row.label &&
+        !elsewhere.has(row.identifier),
+    )
+    .sort(
+      (a, b) =>
+        developer.includes(b.identifier) - developer.includes(a.identifier),
+    );
 }
 
-async function openRow(selector, bounds, loaded) {
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      await accessibility.tap(await findScrolling(selector, bounds), {
-        timeoutMs: tapTimeoutMs,
-      });
-    } catch (error) {
-      if (error.name !== "TimeoutError") {
-        throw error;
-      }
-      await input.pressHome();
-      await sleep(800);
-      await device.launchApplication(settings);
-      await sleep(1_000);
-      continue;
-    }
-    for (let wait = 0; wait < 10; wait++) {
-      await sleep(300);
-      if (loaded(await accessibility.snapshot({ scope: "frontApp" }))) {
-        return;
-      }
+async function openDeviceManagement(developer) {
+  await device.launchApplication(settings, {
+    url: "prefs:root=General&path=ManagedConfigurationList",
+  });
+  const until = Date.now() + 10_000;
+  do {
+    const list = await accessibility.snapshot({ scope: "frontApp" });
+    const rows = developerRows(list, developer);
+    if (rows.length > 0) {
+      return rows;
     }
-  }
-  throw new Error(`Settings did not open ${JSON.stringify(selector)}`);
+    await answerPrompt();
+  } while (Date.now() < until);
+  throw new Error(`Settings lists no app from ${developer}`);
 }
 
-async function back() {
-  const button = await accessibility.find(
-    { app: settings, identifier: "BackButton" },
-    { timeoutMs: 3_000, poll: true },
-  );
-  if (button === null) {
-    throw new Error("Settings shows no back button");
+async function allowDeveloper(row) {
+  const control = {
+    role: "text",
+    label: new RegExp(
+      `.${escaped(row.identifier)}|${escaped(row.identifier)}.`,
+    ),
+  };
+  if ((await inSettings(control, 1_500)) === null) {
+    return false;
   }
-  await accessibility.tap(button, { timeoutMs: tapTimeoutMs });
-  await sleep(600);
+  const until = Date.now() + 5_000;
+  do {
+    const shown = await inSettings(control);
+    if (shown !== null) {
+      await input.tap(shown.point);
+    }
+    const alert = await sheet();
+    const buttons = alert?.findAll({ role: "button" }) ?? [];
+    if (buttons.length === 2) {
+      await dismiss(alert, 0);
+      while (
+        (await inSettings(control)) !== null &&
+        Date.now() < until + 10_000
+      );
+      return true;
+    }
+  } while (Date.now() < until);
+  throw new Error("Settings did not ask to allow the developer");
 }
 
-async function trust(developer, bounds) {
-  await device.launchApplication(settings, { restart: true });
-  await openRow(
-    { identifier: "com.apple.settings.general" },
-    bounds,
-    (opened) =>
-      opened.findAll({ identifier: /^com\.apple\.settings\.general\./ })
-        .length > 0,
-  );
-  await openRow(
-    { identifier: "com.apple.settings.general.vpnAndDeviceManagement" },
-    bounds,
-    (opened) =>
-      opened.findAll({ role: "button", identifier: "VPN" }).length > 0,
-  );
-  const candidates = (list) => {
-    const elsewhere = new Set(
-      list
-        .findAll({
-          role: "button",
-          within: {
-            identifier: "com.apple.settings.sidebar.collectionView",
-          },
-        })
-        .concat(
-          list.findAll({
-            role: "button",
-            within: { role: /^(navigationBar|searchField)$/ },
-          }),
-        )
-        .map((row) => row.identifier),
-    );
-    return list
-      .findAll({ role: "button" })
-      .filter(
-        (row) =>
-          row.identifier !== undefined &&
-          row.identifier !== "BackButton" &&
-          row.identifier !== "VPN" &&
-          row.identifier !== row.label &&
-          !elsewhere.has(row.identifier),
-      )
-      .map((row) => row.identifier);
-  };
-  let rows = [];
-  for (let attempt = 0; attempt < 15 && rows.length === 0; attempt++) {
-    await sleep(400);
-    rows = candidates(await accessibility.snapshot({ scope: "frontApp" }));
-  }
-  for (const row of rows) {
-    const button = await accessibility.find(
-      { app: settings, role: "button", identifier: row },
-      { timeoutMs: 3_000, poll: true },
-    );
+async function trust(developer) {
+  console.debug(`trusting ${developer} in Settings`);
+  const page = { label: new RegExp(escaped(developer)) };
+  for (const row of await openDeviceManagement(developer)) {
+    const until = Date.now() + 3_000;
+    let opened = null;
+    do {
+      await tap(row);
+      opened = await inSettings(page);
+    } while (opened === null && Date.now() < until);
+    if (opened !== null && (await allowDeveloper(row))) {
+      return;
+    }
+    const button = await inSettings({ identifier: "BackButton" }, 3_000);
     if (button === null) {
-      continue;
+      throw new Error("Settings shows no back button");
     }
-    await accessibility.tap(button, { timeoutMs: tapTimeoutMs });
-    let control = null;
-    for (let attempt = 0; attempt < 10 && control === null; attempt++) {
-      await sleep(300);
-      const opened = await accessibility.snapshot({ scope: "frontApp" });
-      if (
-        opened.findAll((it) => (it.label ?? "").includes(developer)).length > 0
-      ) {
-        control =
-          opened
-            .findAll({ role: "text" })
-            .find((it) => it.label !== row && it.label?.includes(row)) ?? null;
-        break;
+    await tap(button);
+  }
+  throw new Error(`Settings lists no app from ${developer}`);
+}
+
+async function waitForUnlock() {
+  let announced = false;
+  for (;;) {
+    try {
+      if (!(await device.locked.get())) {
+        return;
+      }
+    } catch (error) {
+      if (error.name !== "UnavailableError") {
+        throw error;
       }
     }
-    if (control === null) {
-      await back();
-      continue;
+    if (!announced) {
+      console.debug("unlock the device to continue");
+      announced = true;
     }
-    await input.tap(control.point);
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const alert = await sheet();
-      const buttons = alert?.findAll({ role: "button" }) ?? [];
-      if (buttons.length === 2) {
-        await dismiss(alert, buttons, 0);
+  }
+}
+
+async function finishSetup() {
+  const until = Date.now() + 60_000;
+  do {
+    if (!(await answerPrompt())) {
+      const finished = await accessibility.find({
+        app: id,
+        identifier: "setup-finished",
+      });
+      if (finished !== null) {
+        console.log(`${name} is running`);
         return;
       }
-      await sleep(300);
     }
-    throw new Error("Settings did not ask to allow the developer");
-  }
-  throw new Error(`Settings lists no app from ${developer}`);
+  } while (Date.now() < until);
+  throw new Error(`${name} did not finish setting up`);
 }
 
 async function main() {
-  await device.unlock().catch(() => {});
-  const name =
-    (await device.installedApplications()).find((app) => app.bundleId === id)
-      ?.name ?? "Swipt";
-  await allowPrompts(name, 0);
-  const developer = await launch(name);
-  if (developer === null) {
-    console.log(`${name} is running`);
+  if (mode === "prompts") {
+    await finishSetup();
     return;
   }
-  const { screen: bounds } = await device.info();
-  await trust(developer, bounds);
-  await sleep(1_000);
-  if ((await launch(name)) !== null) {
-    throw new Error(`${name} does not open after trusting ${developer}`);
+  console.debug("unlocking the device");
+  await device.unlock().catch(() => {});
+  if (waitsForUnlock === "wait") {
+    await waitForUnlock();
+  }
+  await answerPrompt();
+  const developer = await launch();
+  if (developer !== null) {
+    await trust(developer);
+    console.log(`${developer} is trusted`);
   }
-  console.log(`${name} is running; ${developer} is trusted`);
 }
 
 await main();