@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/chunk-PZZQWRSU.js

@@ -0,0 +1,283 @@
+import {
+  appiumConnection,
+  getIosSession,
+  iosCapabilities,
+  resetIosSession
+} from "./chunk-S6GHOP4B.js";
+import {
+  installAndLaunch,
+  installedAppVersion,
+  launchArgs,
+  listDevices,
+  versionMatches,
+  waitForInstalledVersion
+} from "./chunk-JZDYF3HL.js";
+import {
+  openAndroidDriver,
+  openIosDriver
+} from "./chunk-AXQNUPGC.js";
+import {
+  webOrigin
+} from "./chunk-NLX3V7ZJ.js";
+import {
+  appIdFor,
+  kindOfAppId
+} from "./chunk-NJNTEWXE.js";
+
+// packages/devices/src/testflight.ts
+import { setTimeout as wait } from "timers/promises";
+import { remote } from "webdriverio";
+var testflightBundleId = "com.apple.TestFlight";
+var testflightUi = { settleMs: 2500, maxSwipes: 6 };
+function versionGroupPrefix(version) {
+  return `${version.split("+")[0]},`;
+}
+function buildRowLabel(version) {
+  const [display, build] = version.split("+");
+  return build ? `${display}(${build})` : null;
+}
+function nearestByY(target, items) {
+  return items.reduce((best, item) => !best || Math.abs(item.y - target) < Math.abs(best.y - target) ? item : best, null);
+}
+var byLabel = (browser, predicate) => browser.$(`-ios predicate string:${predicate}`);
+async function findScrolling(browser, predicate) {
+  for (let swipe = 0; swipe <= testflightUi.maxSwipes; swipe += 1) {
+    const element = byLabel(browser, predicate);
+    if (await element.isExisting() && await element.isDisplayed()) return element;
+    await browser.execute("mobile: swipe", { direction: "up" });
+    await wait(1e3);
+  }
+  throw new Error(`TestFlight\uC5D0\uC11C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${predicate}`);
+}
+async function tap(browser, predicate) {
+  await (await findScrolling(browser, predicate)).click();
+  await wait(testflightUi.settleMs);
+}
+async function tapInstallOnRow(browser, version) {
+  const label = buildRowLabel(version);
+  const display = version.split("+")[0];
+  const row = await findScrolling(browser, label ? `type == "XCUIElementTypeStaticText" AND label == "${label}"` : `type == "XCUIElementTypeStaticText" AND label BEGINSWITH "${display}("`);
+  const rowY = (await row.getLocation()).y;
+  const placed = [];
+  for (const button of await browser.$$(`-ios predicate string:type == "XCUIElementTypeButton" AND label == "\uC124\uCE58"`).getElements()) {
+    placed.push({ button, y: (await button.getLocation()).y });
+  }
+  const target = nearestByY(rowY, placed);
+  if (!target) throw new Error(`TestFlight ${label ?? display} \uC904\uC5D0 \u300C\uC124\uCE58\u300D \uBC84\uD2BC\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uC774\uBBF8 \uAE54\uB824 \uC788\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`);
+  await target.button.click();
+  await wait(testflightUi.settleMs);
+  await browser.acceptAlert().catch(() => void 0);
+}
+async function installFromTestflight(udid, version, devAppName, signing = {}) {
+  if (!devAppName) throw new Error("\uC571 \uC124\uC815 install.testflightDevAppName\uC774 \uC5C6\uC5B4 TestFlight\uC5D0\uC11C \uACE0\uB97C \uC571\uC744 \uBAA8\uB985\uB2C8\uB2E4.");
+  const browser = await remote({ ...appiumConnection(), logLevel: "silent", capabilities: iosCapabilities(udid, testflightBundleId, signing) });
+  try {
+    await browser.execute("mobile: terminateApp", { bundleId: testflightBundleId });
+    await browser.execute("mobile: activateApp", { bundleId: testflightBundleId });
+    await wait(testflightUi.settleMs);
+    await tap(browser, `label CONTAINS "${devAppName}"`);
+    await tap(browser, `type == "XCUIElementTypeButton" AND label BEGINSWITH "\uC774\uC804 \uBE4C\uB4DC"`);
+    await tap(browser, `type == "XCUIElementTypeButton" AND label BEGINSWITH "${versionGroupPrefix(version)}"`);
+    await tapInstallOnRow(browser, version);
+  } finally {
+    await browser.deleteSession().catch(() => void 0);
+  }
+}
+
+// packages/server/src/build/firebase.ts
+import { createWriteStream } from "fs";
+import { access, mkdir, rename, rm } from "fs/promises";
+import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { GoogleAuth } from "google-auth-library";
+var buildCacheDir = "test-results/builds";
+var releasesBaseUrl = "https://firebaseappdistribution.googleapis.com/v1";
+var cloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
+var binaryExtensions = { android: "apk", ios: "ipa" };
+function appIdEnvName(platform, kind) {
+  return `FIREBASE_APP_${platform.toUpperCase()}_${kind.toUpperCase()}`;
+}
+function firebaseAppId(platform, kind, install) {
+  const envName = appIdEnvName(platform, kind);
+  const value = (process.env[envName]?.trim() || install?.firebase?.[platform]?.[kind] || "").trim();
+  if (!value) throw new Error(`${envName}\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.`);
+  return value;
+}
+function projectNumber(appId) {
+  const number = appId.split(":")[1];
+  if (!number) throw new Error(`Firebase \uC571 ID \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${appId}`);
+  return number;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toRelease(value) {
+  const fields = ["name", "displayVersion", "buildVersion", "createTime", "binaryDownloadUri"];
+  if (!isRecord(value) || fields.some((field) => typeof value[field] !== "string")) {
+    throw new Error("Firebase \uB9B4\uB9AC\uC2A4 \uC751\uB2F5 \uD615\uC2DD\uC774 \uB2E4\uB985\uB2C8\uB2E4.");
+  }
+  const [name, displayVersion, buildVersion, createTime, binaryDownloadUri] = fields.map((field) => String(value[field]));
+  return { name, displayVersion, buildVersion, createTime, binaryDownloadUri };
+}
+function parsePage(body) {
+  if (!isRecord(body)) throw new Error("Firebase \uB9B4\uB9AC\uC2A4 \uBAA9\uB85D \uC751\uB2F5 \uD615\uC2DD\uC774 \uB2E4\uB985\uB2C8\uB2E4.");
+  const raw = body.releases ?? [];
+  if (!Array.isArray(raw)) throw new Error("Firebase \uB9B4\uB9AC\uC2A4 \uBAA9\uB85D \uC751\uB2F5 \uD615\uC2DD\uC774 \uB2E4\uB985\uB2C8\uB2E4.");
+  const token = typeof body.nextPageToken === "string" && body.nextPageToken ? body.nextPageToken : null;
+  return { releases: raw.map(toRelease), nextPageToken: token };
+}
+async function listReleases(appId, fetchJson) {
+  const baseUrl = `${releasesBaseUrl}/projects/${projectNumber(appId)}/apps/${appId}/releases`;
+  const releases = [];
+  let pageToken = null;
+  do {
+    const url = pageToken ? `${baseUrl}?pageToken=${encodeURIComponent(pageToken)}` : baseUrl;
+    const page = parsePage(await fetchJson(url));
+    releases.push(...page.releases);
+    pageToken = page.nextPageToken;
+  } while (pageToken);
+  return releases;
+}
+function pickRelease(releases, version) {
+  const [displayVersion, buildVersion] = version.split("+");
+  const matches = releases.filter(
+    (release) => release.displayVersion === displayVersion && (!buildVersion || release.buildVersion === buildVersion)
+  );
+  const byNewest = (a, b) => Date.parse(b.createTime) - Date.parse(a.createTime);
+  return [...matches].sort(byNewest)[0] ?? null;
+}
+function cachePath(input, release, root) {
+  const fileName = `${input.platform}-${input.kind}-${release.displayVersion}-${release.buildVersion}.${binaryExtensions[input.platform]}`;
+  return path.join(root, buildCacheDir, fileName);
+}
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function downloadAtomically(url, dest, deps) {
+  const partPath = `${dest}.part`;
+  try {
+    await deps.download(url, partPath);
+    await rename(partPath, dest);
+  } catch (error) {
+    await rm(partPath, { force: true });
+    throw error;
+  }
+}
+async function fetchBuild(input, deps) {
+  const releases = await listReleases(firebaseAppId(input.platform, input.kind, deps.install), deps.fetchJson);
+  const release = pickRelease(releases, input.version);
+  if (!release) throw new Error(`${input.platform} ${input.kind} ${input.version} \uBE4C\uB4DC\uAC00 Firebase\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+  const dest = cachePath(input, release, deps.root ?? process.cwd());
+  if (await exists(dest)) return dest;
+  await mkdir(path.dirname(dest), { recursive: true });
+  try {
+    await downloadAtomically(release.binaryDownloadUri, dest, deps);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`${input.platform} ${input.kind} ${input.version} \uBE4C\uB4DC\uB97C \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${reason}`, { cause: error });
+  }
+  return dest;
+}
+async function downloadToFile(url, dest) {
+  const response = await fetch(url);
+  if (!response.ok || !response.body) throw new Error(`\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328 HTTP ${response.status}`);
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(dest));
+}
+function defaultBuildDeps(install, root) {
+  let auth = null;
+  const fetchJson = async (url) => {
+    const keyFile = process.env.FIREBASE_SERVICE_ACCOUNT?.trim();
+    if (!keyFile) throw new Error("FIREBASE_SERVICE_ACCOUNT\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.");
+    auth ??= new GoogleAuth({ keyFile, scopes: [cloudPlatformScope] });
+    const client = await auth.getClient();
+    const response = await client.request({ url });
+    return response.data;
+  };
+  return { fetchJson, download: downloadToFile, root, install };
+}
+
+// packages/server/src/devices.ts
+var deviceListCacheMs = 2e3;
+async function openDriver(app, device, appId) {
+  if (device.platform === "android") return openAndroidDriver(device.id, appId, webOrigin(app, kindOfAppId(app, appId)), app);
+  return openIosDriver(await getIosSession(device.id, appId, app.ios), appId, app);
+}
+function createDeviceDeps(app, exec, hub) {
+  const buildDeps = defaultBuildDeps(app.install);
+  return {
+    app,
+    // ponytail: appVersion은 dev 앱 기준이다(탐색의 dev 판정과 격자 표시가 같은 값). 운영 앱 버전은 안 보인다.
+    listDevices: () => listDevices(exec, app.appIds.dev, app.iosBundleIds?.dev),
+    fetchBuild: (input) => fetchBuild(input, buildDeps),
+    installAndLaunch: async (device, file, appId, run) => {
+      const result = await installAndLaunch(device, file, appId, run);
+      if (result.ok && device.platform === "ios") {
+        await resetIosSession(device.id);
+        hub.forgetIos(device.id);
+      }
+      return result;
+    },
+    waitForTestflight: async (device, kind, version) => {
+      const appId = appIdFor(app, kind, device.platform);
+      const readInstalled = () => installedAppVersion(exec, device, appId);
+      if (!versionMatches(version, await readInstalled().catch(() => null))) {
+        await resetIosSession(device.id);
+        hub.forgetIos(device.id);
+        await installFromTestflight(device.id, version, app.install.testflightDevAppName, app.ios).catch((error) => console.log(`[farm] TestFlight \uC124\uCE58 \uC2E4\uD328, \uC790\uB3D9 \uC5C5\uB370\uC774\uD2B8\uB97C \uAE30\uB2E4\uB9BD\uB2C8\uB2E4: ${error instanceof Error ? error.message : String(error)}`));
+      }
+      const result = await waitForInstalledVersion({ requested: version, readInstalled });
+      if (!result.ok) return result;
+      await resetIosSession(device.id);
+      hub.forgetIos(device.id);
+      const [command, args] = launchArgs(device, appId);
+      await exec(command, args);
+      return result;
+    },
+    openDriver: (device, appId) => openDriver(app, device, appId)
+  };
+}
+function stateOf(locks, id) {
+  const owner = locks.ownerOf(id);
+  if (owner?.kind === "bot") return "checking";
+  if (owner?.kind === "user") return "controlling";
+  return "idle";
+}
+function createDeviceList(list, locks, now = Date.now) {
+  const seen = /* @__PURE__ */ new Map();
+  let inFlight = null;
+  let cached = null;
+  async function connected() {
+    if (cached && now() - cached.at < deviceListCacheMs) return cached.devices;
+    inFlight ??= list().finally(() => {
+      inFlight = null;
+    });
+    const devices = await inFlight;
+    cached = { at: now(), devices };
+    for (const device of devices) seen.set(device.id, device);
+    return devices;
+  }
+  async function withState() {
+    const devices = await connected();
+    const ids = new Set(devices.map((device) => device.id));
+    const online = devices.map((device) => ({ ...device, state: stateOf(locks, device.id) }));
+    const offline = [...seen.values()].filter((device) => !ids.has(device.id)).map((device) => ({ ...device, state: "offline" }));
+    return [...online, ...offline];
+  }
+  return { connected, withState };
+}
+
+export {
+  firebaseAppId,
+  listReleases,
+  pickRelease,
+  defaultBuildDeps,
+  openDriver,
+  createDeviceDeps,
+  createDeviceList
+};

package/dist/chunk-Q6CXF3NJ.js

@@ -0,0 +1,102 @@
+// packages/core/src/explore/policy.ts
+var mutatingMethods = ["POST", "PUT", "PATCH", "DELETE"];
+var readMethods = ["GET", "HEAD", "OPTIONS"];
+var queryOrHash = /[?#].*$/;
+function stripQuery(path2) {
+  return path2.replace(queryOrHash, "");
+}
+function safeDecode(path2) {
+  try {
+    return decodeURIComponent(path2);
+  } catch {
+    return path2;
+  }
+}
+function isForbiddenPath(path2, patterns) {
+  const candidates = [path2, safeDecode(path2)];
+  return patterns.some((pattern) => candidates.some((candidate) => pattern.test(candidate)));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var templateParam = /\{[^/{}]+\}/g;
+function matchTemplate(template, path2) {
+  const literals = template.split(templateParam).map(escapeRegExp);
+  const source = literals.join("[^/]+");
+  return new RegExp(`^${source}$`).test(path2);
+}
+function isReadMethod(method) {
+  return readMethods.includes(method);
+}
+function findEntry(allowlist, method, path2, status) {
+  return allowlist.entries.some(
+    (entry) => entry.status === status && entry.method.toUpperCase() === method && matchTemplate(entry.path, path2)
+  );
+}
+var isPushTokenRequest = (rules, method, path2) => rules.pushTokenRequests.some((item) => item.method === method && matchTemplate(item.path, path2));
+function decideRequest(method, path2, allowlist, rules) {
+  const upper = method.toUpperCase();
+  if (isReadMethod(upper)) return { allow: true };
+  const pathOnly = stripQuery(path2);
+  if (isPushTokenRequest(rules, upper, pathOnly)) return { allow: true };
+  if (isForbiddenPath(pathOnly, rules.forbiddenApiPatterns)) return { allow: false, reason: "forbidden" };
+  if (findEntry(allowlist, upper, pathOnly, "allow")) return { allow: true };
+  if (findEntry(allowlist, upper, pathOnly, "deny")) return { allow: false, reason: "not-allowed" };
+  return { allow: false, reason: "unknown" };
+}
+function isMutatingMethod(method) {
+  return mutatingMethods.includes(method);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseEntry(value, index) {
+  const where = `allowlist.entries[${index}]`;
+  if (!isRecord(value)) throw new Error(`${where}: \uAC1D\uCCB4\uAC00 \uC544\uB2D9\uB2C8\uB2E4.`);
+  const { method, path: path2, status, note } = value;
+  if (typeof method !== "string" || !isMutatingMethod(method)) throw new Error(`${where}.method: ${mutatingMethods.join("|")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.`);
+  if (typeof path2 !== "string" || !path2.startsWith("/")) throw new Error(`${where}.path: "/"\uB85C \uC2DC\uC791\uD558\uB294 \uBB38\uC790\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.`);
+  if (status !== "allow" && status !== "deny") throw new Error(`${where}.status: allow|deny \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.`);
+  if (note !== void 0 && typeof note !== "string") throw new Error(`${where}.note: \uBB38\uC790\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.`);
+  return { method, path: path2, status, note: note ?? "" };
+}
+function parseAllowlist(value) {
+  if (!isRecord(value) || !Array.isArray(value.entries)) throw new Error("allowlist: { entries: [] } \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4.");
+  return { entries: value.entries.map(parseEntry) };
+}
+function entryKey(method, path2) {
+  return `${method.toUpperCase()} ${path2}`;
+}
+function addMissingAsDeny(allowlist, operations) {
+  const known = new Set(allowlist.entries.map((entry) => entryKey(entry.method, entry.path)));
+  const added = [];
+  for (const operation of operations) {
+    const method = operation.method.toUpperCase();
+    const key = entryKey(method, operation.path);
+    if (!isMutatingMethod(method) || known.has(key)) continue;
+    known.add(key);
+    added.push({ method, path: operation.path, status: "deny", note: "" });
+  }
+  return { allowlist: { entries: [...allowlist.entries, ...added] }, added: added.length };
+}
+
+// packages/engine/src/explore/allowlist-file.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+var defaultAllowlistFile = path.resolve("explore/allowlist.json");
+async function loadAllowlist(file = defaultAllowlistFile) {
+  if (!existsSync(file)) return { entries: [] };
+  const text = await readFile(file, "utf8");
+  return parseAllowlist(JSON.parse(text));
+}
+
+export {
+  readMethods,
+  decideRequest,
+  isMutatingMethod,
+  parseAllowlist,
+  addMissingAsDeny,
+  defaultAllowlistFile,
+  loadAllowlist
+};

package/dist/chunk-S6GHOP4B.js

@@ -0,0 +1,111 @@
+// packages/devices/src/ios-session.ts
+import { remote } from "webdriverio";
+var defaultAppiumUrl = "http://127.0.0.1:4723";
+var iosMjpegPort = 9100;
+var iosNewCommandTimeoutSec = 600;
+var iosMjpegSettings = {
+  mjpegServerFramerate: 30,
+  mjpegScalingFactor: 50,
+  mjpegServerScreenshotQuality: 35
+};
+var defaultWdaBundleId = "com.example.WebDriverAgentRunner";
+function iosCapabilities(udid, appId, signing = {}) {
+  const teamId = signing.teamId || process.env.IOS_TEAM_ID;
+  const wdaBundleId = signing.wdaBundleId || process.env.IOS_WDA_BUNDLE_ID || defaultWdaBundleId;
+  return {
+    platformName: "iOS",
+    "appium:automationName": "XCUITest",
+    "appium:udid": udid,
+    "appium:bundleId": appId,
+    "appium:noReset": true,
+    // 기본 60초면 화면 하나가 오래 걸릴 때 세션이 끊기고 남은 화면이 모두 「세션 종료」로 실패한다.
+    "appium:newCommandTimeout": iosNewCommandTimeoutSec,
+    "appium:showSafariConsoleLog": true,
+    "appium:showSafariNetworkLog": true,
+    "appium:mjpegServerPort": iosMjpegPort,
+    ...teamId ? {
+      "appium:xcodeOrgId": teamId,
+      "appium:xcodeSigningId": "Apple Development",
+      "appium:updatedWDABundleId": wdaBundleId,
+      "appium:allowProvisioningDeviceRegistration": true
+    } : {}
+  };
+}
+function appiumConnection() {
+  const url = new URL(process.env.APPIUM_URL || defaultAppiumUrl);
+  return {
+    protocol: url.protocol.replace(":", ""),
+    hostname: url.hostname,
+    port: Number(url.port || defaultPortOf(url.protocol)),
+    path: url.pathname
+  };
+}
+function defaultPortOf(protocol) {
+  return protocol === "https:" ? 443 : 80;
+}
+var sessions = /* @__PURE__ */ new Map();
+var lastAliveAt = /* @__PURE__ */ new Map();
+var sessionCheckIntervalMs = 5e3;
+var deadSessionPattern = /invalid session id|session is either terminated|session .* (not found|does not exist)|ECONNREFUSED|socket hang up|Could not proxy command/i;
+function isDeadSessionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return deadSessionPattern.test(message);
+}
+async function getIosSession(udid, appId, signing = {}) {
+  const existing = sessions.get(udid);
+  if (!existing) return openIosSession(udid, appId, signing);
+  const session = await existing;
+  if (Date.now() - (lastAliveAt.get(udid) ?? 0) < sessionCheckIntervalMs) return session;
+  try {
+    await session.getWindowSize();
+    lastAliveAt.set(udid, Date.now());
+    return session;
+  } catch (error) {
+    if (!isDeadSessionError(error)) throw error;
+    if (sessions.get(udid) === existing) sessions.delete(udid);
+    return openIosSession(udid, appId, signing);
+  }
+}
+function openIosSession(udid, appId, signing) {
+  const pending = sessions.get(udid);
+  if (pending) return pending;
+  const opening = remote({ ...appiumConnection(), logLevel: "warn", capabilities: iosCapabilities(udid, appId, signing) });
+  sessions.set(udid, opening);
+  opening.then(
+    (session) => {
+      lastAliveAt.set(udid, Date.now());
+      session.updateSettings(iosMjpegSettings).catch(() => void 0);
+    },
+    () => {
+      if (sessions.get(udid) === opening) sessions.delete(udid);
+    }
+  );
+  return opening;
+}
+async function deleteQuietly(opening) {
+  try {
+    const session = await opening;
+    await session.deleteSession();
+  } catch {
+  }
+}
+async function resetIosSession(udid) {
+  const opening = sessions.get(udid);
+  sessions.delete(udid);
+  if (opening) await deleteQuietly(opening);
+}
+async function closeAllIosSessions() {
+  const openings = [...sessions.values()];
+  sessions.clear();
+  await Promise.all(openings.map(deleteQuietly));
+}
+
+export {
+  iosMjpegPort,
+  iosCapabilities,
+  appiumConnection,
+  isDeadSessionError,
+  getIosSession,
+  resetIosSession,
+  closeAllIosSessions
+};