@ahnseungchan/device-farm 0.0.0-stage → 0.1.0

package/dist/chaos-CIB7G5X5.js

@@ -0,0 +1,453 @@
+import {
+  startCollectors
+} from "./chunk-ZE2GGXFO.js";
+import {
+  LogRing,
+  defaultGuard,
+  loadExploreInputs,
+  probeScreen
+} from "./chunk-AVECSGEH.js";
+import "./chunk-UAHWEUDI.js";
+import "./chunk-F6PZOBU6.js";
+import "./chunk-Q6CXF3NJ.js";
+import {
+  hasForbiddenWord,
+  listActionsScript
+} from "./chunk-SWW42KTA.js";
+import "./chunk-S6GHOP4B.js";
+import {
+  listDevices
+} from "./chunk-JZDYF3HL.js";
+import {
+  cliApp,
+  farmPort
+} from "./chunk-7OJDY276.js";
+import {
+  execFileText,
+  openAndroidDriver
+} from "./chunk-AXQNUPGC.js";
+import {
+  sleep,
+  webOrigin
+} from "./chunk-NLX3V7ZJ.js";
+import "./chunk-NJNTEWXE.js";
+
+// apps/cli/src/chaos.ts
+import path2 from "path";
+
+// packages/engine/src/chaos/run.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+
+// packages/core/src/chaos/policy.ts
+var baseWeights = {
+  press: 1,
+  back: 0.3,
+  tab: 0.2,
+  doubleTap: 0.15,
+  backDuringLoad: 0.15,
+  background: 0.1,
+  restart: 0.05,
+  homeReset: 0.05
+};
+var multipliers = { newState: 2, nearError: 3, dead: 0.2 };
+var deadAfter = 2;
+var pressMassCap = 3;
+var stayStepsPerBoost = 2;
+var linkBonus = 1.5;
+var frontierBonus = 3;
+var deeperBonus = 1.5;
+var pathDepth = (path3) => path3.split("/").filter(Boolean).length;
+var leaveKinds = ["back", "tab", "homeReset"];
+function isNoPressPath(path3, pattern = /password|\/pin(\/|$)/i) {
+  return pattern.test(path3);
+}
+var actionKey = (action) => [action.kind, action.role ?? "", action.name ?? ""].join(":");
+function isAvoidedName(name, pattern) {
+  return pattern.test(name);
+}
+function canGoBack(screen) {
+  if (screen.targets.some((target) => screen.nav.inPageBackNames.includes(target.name))) return true;
+  return !Object.values(screen.nav.tabPaths).includes(screen.path);
+}
+function chaosCandidates(screen) {
+  const tabNames = Object.keys(screen.nav.tabPaths);
+  const press = isNoPressPath(screen.path, screen.nav.noPressPathPattern) ? [] : screen.targets.filter((target) => !tabNames.includes(target.name));
+  const tabs = screen.targets.filter((target) => target.role === "link" && tabNames.includes(target.name));
+  const last = screen.lastPressed;
+  const lastVisible = last && press.some((target) => target.role === last.role && target.name === last.name);
+  return [
+    ...press.map((target) => ({ kind: "press", ...target })),
+    ...canGoBack(screen) ? [{ kind: "back" }] : [],
+    ...tabs.length > 0 ? [{ kind: "tab" }] : [],
+    ...lastVisible ? [{ kind: "doubleTap", ...last }] : [],
+    ...press.length > 0 ? [{ kind: "backDuringLoad" }] : [],
+    { kind: "background" },
+    { kind: "restart" },
+    { kind: "homeReset" }
+  ];
+}
+function baseScore(action, context) {
+  const stayFactor = 1 + context.stay / stayStepsPerBoost;
+  if (action.kind === "press") {
+    const share = baseWeights.press * Math.min(1, pressMassCap / Math.max(1, context.pressCount));
+    const frontier = action.to && context.visited && !context.visited(action.to) ? frontierBonus : 1;
+    const deeper = action.to && context.path !== void 0 && pathDepth(action.to) > pathDepth(context.path) ? deeperBonus : 1;
+    return share * (action.role === "link" ? linkBonus : 1) * frontier * deeper / stayFactor;
+  }
+  return leaveKinds.includes(action.kind) ? baseWeights[action.kind] * stayFactor : baseWeights[action.kind];
+}
+function scoreAction(action, stats, context = { pressCount: 1, stay: 0 }) {
+  const base = baseScore(action, context);
+  if (!stats) return base;
+  return base / (1 + stats.tries) * (stats.openedNew ? multipliers.newState : 1) * (stats.errors > 0 ? multipliers.nearError : 1) * (stats.dead >= deadAfter ? multipliers.dead : 1);
+}
+var statsKey = (path3, action) => `${path3}|${actionKey(action)}`;
+function scoreAll(candidates, statsOf, path3, stay = 0, visited) {
+  const context = { pressCount: candidates.filter((action) => action.kind === "press").length, stay, visited, path: path3 };
+  const scored = candidates.map((action) => ({ action, score: scoreAction(action, statsOf(statsKey(path3, action)), context) }));
+  const total = scored.reduce((sum, item) => sum + item.score, 0);
+  return scored.map((item) => ({ ...item, probability: total > 0 ? item.score / total : 0 }));
+}
+function seededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function pickWeighted(items, random) {
+  const total = items.reduce((sum, item) => sum + item.score, 0);
+  let point = random() * total;
+  for (const item of items) {
+    point -= item.score;
+    if (point < 0) return item;
+  }
+  return items[items.length - 1];
+}
+
+// packages/core/src/chaos/judge.ts
+var errorKinds = ["app-error", "crash", "console", "network", "blank", "login-redirect", "stuck"];
+var guardAbortText = "ERR_BLOCKED_BY_CLIENT";
+var relaunchGraceMs = 5e3;
+function causedByChaos(issue, context) {
+  if (issue.kind === "console" && issue.message.includes(guardAbortText)) return true;
+  if (context.guardBlocked && (issue.kind === "console" || issue.kind === "network")) return true;
+  return issue.kind === "blank" && context.sinceRelaunchMs < relaunchGraceMs;
+}
+function judgeIssues(issues, context) {
+  const errors = issues.filter((issue) => errorKinds.includes(issue.kind) && !causedByChaos(issue, context));
+  return { errors, warnings: issues.filter((issue) => !errors.includes(issue)) };
+}
+var dedupeMessageLength = 80;
+function errorKey(issue) {
+  return `${issue.kind}|${issue.message.replace(/\d+/g, "N").slice(0, dedupeMessageLength)}`;
+}
+function dedupeErrors(judgement, seen) {
+  const fresh = [];
+  const repeated = [];
+  for (const issue of judgement.errors) {
+    const key = errorKey(issue);
+    if (seen.has(key)) {
+      repeated.push(issue);
+      continue;
+    }
+    seen.add(key);
+    fresh.push(issue);
+  }
+  return { errors: fresh, warnings: [...judgement.warnings, ...repeated] };
+}
+
+// packages/engine/src/chaos/run.ts
+var settleMs = 1500;
+var backDuringLoadMs = 300;
+var backgroundMs = 3e3;
+var restartWaitMs = 8e3;
+var doubleTapCount = 3;
+var stuckAfterFailures = 3;
+var recordedCandidates = 8;
+async function attach(deps, blocked) {
+  const driver = await deps.openDriver();
+  const stopGuard = await deps.guard(driver, (line) => blocked.push(line));
+  const ring = new LogRing();
+  const stopCollectors = await startCollectors(deps.device, deps.appId, driver, ring);
+  return { driver, stopGuard, stopCollectors, ring, blocked };
+}
+async function detach(session) {
+  await session.stopCollectors().catch(() => void 0);
+  await session.stopGuard().catch(() => void 0);
+  await session.driver.close().catch(() => void 0);
+}
+var adb = (session, ...args) => session.deps.exec("adb", ["-s", session.deps.device.id, "shell", ...args]);
+async function launchApp(session) {
+  await adb(session, "monkey", "-p", session.deps.appId, "1");
+}
+function parseForegroundPackage(dumpsys) {
+  return /topResumedActivity=ActivityRecord\{\S+ \S+ ([^/\s]+)\//.exec(dumpsys)?.[1] ?? null;
+}
+async function foregroundPackage(session) {
+  return parseForegroundPackage(await adb(session, "dumpsys", "activity", "activities").catch(() => ""));
+}
+async function returnToApp(session) {
+  await launchApp(session);
+  await sleep(settleMs);
+  const readable = await session.driver.currentPath().then(() => true, () => false);
+  if (!readable) await restartApp(session);
+}
+var linkTargetsScript = `(() => {
+  const nameOf = (el) => (el.getAttribute("aria-label") || el.innerText || el.title || "").replace(/\\s+/g, " ").trim();
+  return Array.from(document.querySelectorAll("a[href]")).flatMap((el) => {
+    try {
+      const url = new URL(el.href);
+      return url.origin === location.origin ? [[nameOf(el), url.pathname]] : [];
+    } catch (error) {
+      return [];
+    }
+  });
+})()`;
+var dialogCountScript = `document.querySelectorAll('[role="dialog"], [aria-modal="true"]').length`;
+async function readScreen(driver) {
+  const path3 = await driver.currentPath();
+  const all = await driver.evaluate(listActionsScript).catch(() => []);
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const item of all) {
+    if (item.role === "input" || hasForbiddenWord(item.name, driver.app.guard.forbiddenButtonWords) || isAvoidedName(item.name, driver.app.guard.avoidedNamePattern)) continue;
+    const key = `${item.role}:${item.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    targets.push({ role: item.role, name: item.name });
+  }
+  const text = await driver.evaluate("(document.body ? document.body.innerText : '').replace(/\\s+/g, ' ')").catch(() => "");
+  const dialogs = await driver.evaluate(dialogCountScript).catch(() => 0);
+  const hrefs = new Map(await driver.evaluate(linkTargetsScript).catch(() => []));
+  for (const target of targets) if (target.role === "link" && hrefs.has(target.name)) target.to = hrefs.get(target.name);
+  return { path: path3, targets, state: `${path3}|\uD31D\uC5C5 ${dialogs}`, fingerprint: `${path3}|${text.length}|${text.slice(0, 200)}` };
+}
+async function pressBack(session, targets) {
+  const inPage = targets.find((target) => session.driver.app.inPageBackNames.includes(target.name));
+  if (inPage) return session.driver.clickButton(inPage.name, inPage.role);
+  await adb(session, "input", "keyevent", "KEYCODE_BACK");
+}
+async function perform(session, action, targets, random) {
+  const { driver } = session;
+  if (action.kind === "press") return driver.clickButton(action.name ?? "", action.role);
+  if (action.kind === "tab") {
+    const tabNames = Object.keys(driver.app.tabPaths);
+    const tabs = targets.filter((target) => target.role === "link" && tabNames.includes(target.name));
+    const tab = tabs[Math.floor(random() * tabs.length)];
+    action.role = tab.role;
+    action.name = tab.name;
+    return driver.clickButton(tab.name, tab.role);
+  }
+  if (action.kind === "back") return pressBack(session, targets);
+  if (action.kind === "homeReset") return driver.goHome?.();
+  if (action.kind === "doubleTap") {
+    for (let i = 0; i < doubleTapCount; i += 1) await driver.clickButton(action.name ?? "", action.role);
+    return;
+  }
+  if (action.kind === "backDuringLoad") {
+    const pressable = targets.filter((target2) => !driver.app.inPageBackNames.includes(target2.name));
+    const target = pressable[Math.floor(random() * pressable.length)];
+    action.role = target.role;
+    action.name = target.name;
+    await driver.clickButton(target.name, target.role);
+    await sleep(backDuringLoadMs);
+    return pressBack(session, []);
+  }
+  if (action.kind === "background") {
+    await adb(session, "input", "keyevent", "KEYCODE_HOME");
+    await sleep(backgroundMs);
+    await launchApp(session);
+    session.relaunchedAt = Date.now();
+    return;
+  }
+  return restartApp(session);
+}
+async function restartApp(session) {
+  await adb(session, "am", "force-stop", session.deps.appId);
+  await detach(session);
+  await launchApp(session);
+  await sleep(restartWaitMs);
+  Object.assign(session, await attach(session.deps, session.blocked));
+  session.relaunchedAt = Date.now();
+}
+async function startEpisode(session, log) {
+  try {
+    await session.driver.goHome?.();
+    return;
+  } catch (error) {
+    log(`\uD648 \uC774\uB3D9 \uC2E4\uD328, \uC571 \uC7AC\uC2DC\uC791: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+  }
+  await restartApp(session);
+  await session.driver.goHome?.().catch((error) => log(`\uC7AC\uC2DC\uC791 \uB4A4\uC5D0\uB3C4 \uD648 \uC774\uB3D9 \uC2E4\uD328: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`));
+}
+function describe(action) {
+  return action.name ? `${action.kind} \u300C${action.name}\u300D` : action.kind;
+}
+function bumpStats(stats, key, outcome) {
+  const current = stats.get(key) ?? { tries: 0, openedNew: false, errors: 0, dead: 0 };
+  stats.set(key, {
+    tries: current.tries + 1,
+    openedNew: current.openedNew || outcome.newState,
+    errors: current.errors + outcome.errors,
+    dead: current.dead + (outcome.dead ? 1 : 0)
+  });
+}
+async function saveScreenshot(session, dir, name) {
+  const png = await session.driver.screenshot().catch(() => null);
+  if (!png) return void 0;
+  writeFileSync(path.join(dir, name), png);
+  return name;
+}
+async function runChaos(deps) {
+  const log = deps.log ?? (() => void 0);
+  const random = seededRandom(deps.seed);
+  const runId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-s${deps.seed}`;
+  const dir = path.join(deps.resultsDir, runId);
+  mkdirSync(dir, { recursive: true });
+  const run = { runId, deviceId: deps.device.id, seed: deps.seed, startedAt: (/* @__PURE__ */ new Date()).toISOString(), finishedAt: null, steps: [], states: 0, blocked: [] };
+  const save = () => writeFileSync(path.join(dir, "run.json"), `${JSON.stringify(run, null, 2)}
+`);
+  const blocked = [];
+  const session = { deps, relaunchedAt: 0, ...await attach(deps, blocked) };
+  const stats = /* @__PURE__ */ new Map();
+  const seenStates = /* @__PURE__ */ new Set();
+  const visitedPaths = /* @__PURE__ */ new Set();
+  const seenErrors = /* @__PURE__ */ new Set();
+  let failuresInRow = 0;
+  let blockedAtPreviousStep = 0;
+  const deadline = Date.now() + deps.minutes * 6e4;
+  try {
+    for (let episode = 1; episode <= deps.episodes && Date.now() < deadline; episode += 1) {
+      await startEpisode(session, log);
+      let lastPressed;
+      let stay = 0;
+      let lastPath = "";
+      for (let step = 1; step <= deps.stepsPerEpisode && Date.now() < deadline; step += 1) {
+        const before = await readScreen(session.driver).catch(async (error) => {
+          log(`\uD654\uBA74 \uC77D\uAE30 \uC2E4\uD328, \uC571\uC73C\uB85C \uBCF5\uADC0: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+          await returnToApp(session);
+          return readScreen(session.driver);
+        });
+        seenStates.add(before.state);
+        visitedPaths.add(before.path);
+        stay = before.path === lastPath ? stay + 1 : 0;
+        lastPath = before.path;
+        const scored = scoreAll(chaosCandidates({ path: before.path, targets: before.targets, lastPressed, nav: { ...session.driver.app, noPressPathPattern: session.driver.app.guard.noPressPathPattern } }), (key2) => stats.get(key2), before.path, stay, (path3) => visitedPaths.has(path3));
+        const chosen = pickWeighted(scored, random);
+        const key = actionKey(chosen.action);
+        const recordKey = statsKey(before.path, chosen.action);
+        const action = { ...chosen.action };
+        const since = Date.now();
+        const blockedBefore = blockedAtPreviousStep;
+        blockedAtPreviousStep = blocked.length;
+        let failure;
+        try {
+          await perform(session, action, before.targets, random);
+        } catch (error) {
+          failure = error instanceof Error ? error.message.split("\n")[0] : String(error);
+        }
+        await sleep(settleMs);
+        const foreground = await foregroundPackage(session);
+        const leftApp = foreground && foreground !== deps.appId ? foreground : void 0;
+        const after = leftApp ? { ...before, path: `(\uB2E4\uB978 \uC571 ${leftApp})`, state: `(\uB2E4\uB978 \uC571 ${leftApp})`, fingerprint: "" } : await readScreen(session.driver).catch(() => ({ ...before, path: "(\uC77D\uAE30 \uC2E4\uD328)", state: "(\uC77D\uAE30 \uC2E4\uD328)", fingerprint: "" }));
+        const newState = !seenStates.has(after.state);
+        seenStates.add(after.state);
+        const dead = action.kind === "press" && !failure && after.fingerprint === before.fingerprint;
+        const issues = await probeScreen(session.driver, session.ring, since, deps.allowlist).catch(() => []);
+        const { errors, warnings } = dedupeErrors(judgeIssues(issues, { sinceRelaunchMs: Date.now() - session.relaunchedAt, guardBlocked: blocked.length > blockedBefore }), seenErrors);
+        bumpStats(stats, recordKey, { newState, dead, errors: errors.length });
+        if (action.kind === "press") lastPressed = { role: action.role ?? "button", name: action.name ?? "" };
+        const record = {
+          episode,
+          step,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          from: before.path,
+          state: before.state,
+          candidates: [...scored].sort((a, b) => b.score - a.score).slice(0, recordedCandidates).map((item) => ({ key: actionKey(item.action), score: Number(item.score.toFixed(3)), probability: Number(item.probability.toFixed(3)) })),
+          chosen: action.name ? `${key}${chosen.action.name ? "" : action.name}` : key,
+          chosenProbability: Number(chosen.probability.toFixed(3)),
+          to: after.path,
+          newState,
+          dead,
+          errors,
+          warnings,
+          ...failure ? { failure } : {},
+          ...leftApp ? { leftApp } : {}
+        };
+        failuresInRow = failure ? failuresInRow + 1 : 0;
+        if (failuresInRow >= stuckAfterFailures) {
+          record.errors.push({ kind: "stuck", message: `${before.path}\uC5D0\uC11C \uD589\uB3D9 ${failuresInRow}\uBC88\uC774 \uC5F0\uB2EC\uC544 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4(\uB9C8\uC9C0\uB9C9: ${failure}). \uC571\uC744 \uC7AC\uC2DC\uC791\uD569\uB2C8\uB2E4.` });
+        }
+        if (record.errors.length > 0) record.screenshot = await saveScreenshot(session, dir, `e${episode}-s${step}.png`);
+        run.steps.push(record);
+        run.states = seenStates.size;
+        run.blocked = [...blocked];
+        save();
+        if (failuresInRow >= stuckAfterFailures) {
+          failuresInRow = 0;
+          await restartApp(session);
+          await startEpisode(session, log);
+        } else if (leftApp) {
+          await returnToApp(session);
+        }
+        log(`[${episode}-${step}] ${before.path} \u2192 ${describe(action)} (${(chosen.probability * 100).toFixed(0)}%) \u2192 ${after.path}${newState ? " \uC0C8 \uC0C1\uD0DC" : ""}${dead ? " \uBC18\uC751 \uC5C6\uC74C" : ""}${failure ? ` \uC2E4\uD328: ${failure}` : ""}${errors.length ? ` \uC624\uB958: ${errors.map((e) => e.kind).join(",")}` : ""}`);
+      }
+    }
+  } finally {
+    run.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    save();
+    await detach(session);
+  }
+  return run;
+}
+
+// apps/cli/src/chaos.ts
+function option(name, fallback) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+async function farmBusy() {
+  const response = await fetch(`http://127.0.0.1:${farmPort()}/api/devices/runs/latest`).catch(() => null);
+  if (!response?.ok) return false;
+  const run = await response.json().catch(() => null);
+  return Boolean(run && run.finishedAt === null);
+}
+async function main() {
+  const app = await cliApp();
+  const serial = option("device");
+  if (!serial) throw new Error("--device <Android serial>\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.");
+  if (await farmBusy()) throw new Error("\uB514\uBC14\uC774\uC2A4\uD31C \uC810\uAC80\uC774 \uB3C4\uB294 \uC911\uC774\uB77C \uAE30\uAE30\uB97C \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  const device = (await listDevices(execFileText, app.appIds.dev)).find((item) => item.id === serial && item.platform === "android");
+  if (!device) throw new Error(`\uC5F0\uACB0\uB41C Android \uAE30\uAE30\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${serial}`);
+  const origin = webOrigin(app, "dev");
+  const { allowlist } = loadExploreInputs();
+  const noGuard = process.argv.includes("--no-guard");
+  if (noGuard) console.log(`\uC4F0\uAE30 \uC694\uCCAD\uC744 \uB9C9\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(dev ${origin}).`);
+  const run = await runChaos({
+    device,
+    appId: app.appIds.dev,
+    exec: execFileText,
+    openDriver: () => openAndroidDriver(device.id, app.appIds.dev, origin, app),
+    guard: noGuard ? async () => async () => void 0 : (driver, onBlocked) => defaultGuard(driver, origin, allowlist, (request) => onBlocked(`${request.method} ${request.path}`)),
+    allowlist,
+    seed: Number(option("seed", String(Date.now() % 1e5))),
+    episodes: Number(option("episodes", "3")),
+    stepsPerEpisode: Number(option("steps", "50")),
+    minutes: Number(option("minutes", "60")),
+    resultsDir: path2.resolve("test-results/chaos"),
+    log: (line) => console.log(line)
+  });
+  const errors = run.steps.filter((step) => step.errors.length > 0);
+  console.log(`
+\uB05D: \uC2A4\uD15D ${run.steps.length} \xB7 \uC0C1\uD0DC ${run.states} \xB7 \uC624\uB958 \uC2A4\uD15D ${errors.length} \xB7 \uB9C9\uC740 \uC4F0\uAE30 ${run.blocked.length}`);
+  console.log(`\uAE30\uB85D: test-results/chaos/${run.runId}/run.json`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});

package/dist/chunk-3GCH6TN3.js

@@ -0,0 +1,86 @@
+import {
+  runRule
+} from "./chunk-OUNLQI2N.js";
+import {
+  samePath,
+  sleep
+} from "./chunk-NLX3V7ZJ.js";
+
+// packages/core/src/qa/run.ts
+var qaSettleMs = 4e3;
+var qaFetchWaitMs = 15e3;
+var qaPollMs = 500;
+var qaAttempts = 2;
+var resultKey = "__deviceFarmQa";
+function fetchScript(apiOrigin, apis, sessionPath = "/api/auth/session") {
+  return `(function () {
+    window.${resultKey} = null;
+    var apis = ${JSON.stringify(Object.entries(apis))};
+    fetch(${JSON.stringify(sessionPath)}).then(function (r) { return r.json(); }).then(function (session) {
+      var user = (session && session.user) || {};
+      if (!user.id || !user.accessToken) throw new Error("\uB85C\uADF8\uC778 \uC138\uC158\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+      return Promise.all(apis.map(function (entry) {
+        var path = entry[1].replace("{userId}", encodeURIComponent(String(user.id)));
+        var started = Date.now();
+        return fetch(${JSON.stringify(apiOrigin)} + path, { method: "GET", headers: { Authorization: "Bearer " + user.accessToken }, credentials: "include" })
+          .then(function (r) { return r.text().then(function (body) { return { name: entry[0], path: path.replace(String(user.id), "{userId}"), status: r.status, durationMs: Date.now() - started, body: body }; }); });
+      }));
+    }).then(function (list) { window.${resultKey} = { ok: true, list: list }; }, function (error) { window.${resultKey} = { ok: false, error: String(error && error.message || error) }; });
+    return true;
+  })()`;
+}
+async function fetchInPage(driver, apiOrigin, apis, waitMs) {
+  await driver.evaluate(fetchScript(apiOrigin, apis, driver.app.qa.sessionPath));
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    await sleep(qaPollMs);
+    const result = await driver.evaluate(`window.${resultKey}`);
+    if (result) return result;
+  }
+  return { ok: false, error: `${waitMs / 1e3}\uCD08 \uC548\uC5D0 API \uC751\uB2F5\uC744 \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.` };
+}
+function parseBody(body) {
+  try {
+    return { value: JSON.parse(body) };
+  } catch {
+    return { error: "JSON\uC774 \uC544\uB2D9\uB2C8\uB2E4." };
+  }
+}
+async function openScreen(driver, path) {
+  const { tabPaths, homeTabName } = driver.app;
+  const tab = Object.entries(tabPaths).find(([, tabPath]) => samePath(tabPath, path));
+  if (!tab || !driver.goHome) return driver.navigate(path);
+  await driver.goHome();
+  if (tab[0] !== homeTabName) await driver.clickButton(tab[0], "link");
+}
+var failedReport = (screen, check) => ({ path: screen.path, name: screen.name, apis: [], checks: [check] });
+async function checkOpenScreen(driver, screen, apiOrigin, fetchWaitMs) {
+  const raw = await fetchInPage(driver, apiOrigin, screen.apis, fetchWaitMs);
+  if (!raw.ok) return failedReport(screen, { id: "fetch", title: "API \uC870\uD68C", ok: false, message: raw.error });
+  const responses = {};
+  const apis = raw.list.map(({ name, path, status, durationMs, body }) => {
+    const parsed = parseBody(body);
+    if (parsed.value !== void 0 && status === 200) responses[name] = parsed.value;
+    return { name, path, status, durationMs, ...parsed.error ? { error: parsed.error } : {} };
+  });
+  const apiChecks = apis.filter((api) => api.status !== 200 || api.error).map((api) => ({ id: `api-${api.name}`, title: `API ${api.path}`, ok: false, message: api.error ?? `\uC0C1\uD0DC ${api.status}` }));
+  const text = await driver.evaluate("document.body.innerText");
+  return { path: screen.path, name: screen.name, apis, checks: [...apiChecks, ...screen.rules.map((rule) => runRule(rule, { responses, text }))] };
+}
+async function openAndSettle(driver, screen, settleMs) {
+  await openScreen(driver, screen.path);
+  await sleep(settleMs);
+  const opened = await driver.currentPath();
+  return samePath(screen.path, opened) ? null : failedReport(screen, { id: "open", title: "\uD654\uBA74 \uC5F4\uAE30", ok: false, message: `${screen.path} \uB300\uC2E0 ${opened} \uD654\uBA74\uC774 \uC5F4\uB824 \uC788\uC2B5\uB2C8\uB2E4.` });
+}
+async function runScreenQa(driver, screen, options) {
+  const { apiOrigin, settleMs = qaSettleMs, fetchWaitMs = qaFetchWaitMs } = options;
+  const attempt = async () => await openAndSettle(driver, screen, settleMs) ?? await checkOpenScreen(driver, screen, apiOrigin, fetchWaitMs);
+  let report = await attempt();
+  for (let tried = 1; tried < qaAttempts && report.checks.some((check) => !check.ok); tried += 1) report = await attempt();
+  return report;
+}
+
+export {
+  runScreenQa
+};

package/dist/chunk-4UOXXMXL.js

@@ -0,0 +1,74 @@
+// apps/cli/src/args.ts
+var defaultPort = 5173;
+var versionPattern = /^\d+\.\d+\.\d+(\+\d+)?$/;
+var maxPort = 65535;
+var runOptions = ["build", "version", "devices", "port"];
+var exploreOptions = ["build", "devices", "port"];
+function readOptions(argv, allowed) {
+  const options = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) return { ok: false, error: `\uC54C \uC218 \uC5C6\uB294 \uC778\uC790\uC785\uB2C8\uB2E4: ${token}` };
+    const [rawKey, inline] = token.slice(2).split(/=(.*)/s, 2);
+    if (!allowed.includes(rawKey)) return { ok: false, error: `\uC54C \uC218 \uC5C6\uB294 \uC635\uC158\uC785\uB2C8\uB2E4: --${rawKey}` };
+    const value = inline ?? argv[index + 1];
+    if (value === void 0 || value.startsWith("--")) return { ok: false, error: `--${rawKey} \uAC12\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.` };
+    if (inline === void 0) index += 1;
+    options.set(rawKey, value);
+  }
+  return { ok: true, value: options };
+}
+function parseBuild(value) {
+  if (value === void 0) return { ok: false, error: "--build\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. (dev | prod)" };
+  if (value === "dev" || value === "prod") return { ok: true, value };
+  return { ok: false, error: `--build\uB294 dev \uB610\uB294 prod\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${value}` };
+}
+function parseVersion(value) {
+  if (value === void 0) return { ok: false, error: "--version\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. (\uC608: 2.1.5 \uB610\uB294 2.1.5+412)" };
+  if (versionPattern.test(value)) return { ok: true, value };
+  return { ok: false, error: `--version \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${value} (\uC608: 2.1.5 \uB610\uB294 2.1.5+412)` };
+}
+function parseDevices(value) {
+  if (value === void 0 || value === "all") return { ok: true, value: "all" };
+  const ids = value.split(",").map((id) => id.trim());
+  if (ids.some((id) => id === "")) return { ok: false, error: `--devices \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${value} (all \uB610\uB294 id,id)` };
+  return { ok: true, value: ids };
+}
+function parsePort(value) {
+  if (value === void 0) return { ok: true, value: defaultPort };
+  const port = Number(value);
+  if (/^\d+$/.test(value) && port >= 1 && port <= maxPort) return { ok: true, value: port };
+  return { ok: false, error: `--port\uB294 1~${maxPort} \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${value}` };
+}
+function parseRunArgs(argv) {
+  const options = readOptions(argv, runOptions);
+  if (!options.ok) return options;
+  const kind = parseBuild(options.value.get("build"));
+  if (!kind.ok) return kind;
+  const version = parseVersion(options.value.get("version"));
+  if (!version.ok) return version;
+  const devices = parseDevices(options.value.get("devices"));
+  if (!devices.ok) return devices;
+  const port = parsePort(options.value.get("port"));
+  if (!port.ok) return port;
+  return { ok: true, value: { kind: kind.value, version: version.value, devices: devices.value, port: port.value } };
+}
+function parseExploreArgs(argv) {
+  const options = readOptions(argv, exploreOptions);
+  if (!options.ok) return options;
+  const devices = parseDevices(options.value.get("devices"));
+  if (!devices.ok) return devices;
+  const port = parsePort(options.value.get("port"));
+  if (!port.ok) return port;
+  const rawBuild = options.value.get("build");
+  if (rawBuild === void 0) return { ok: true, value: { devices: devices.value, port: port.value } };
+  const build = parseBuild(rawBuild);
+  if (!build.ok) return build;
+  return { ok: true, value: { devices: devices.value, port: port.value, build: build.value } };
+}
+
+export {
+  defaultPort,
+  parseRunArgs,
+  parseExploreArgs
+};

package/dist/chunk-7OJDY276.js

@@ -0,0 +1,16 @@
+import {
+  loadAppConfig,
+  loadDotEnv
+} from "./chunk-NLX3V7ZJ.js";
+
+// apps/cli/src/app.ts
+async function cliApp() {
+  loadDotEnv();
+  return loadAppConfig();
+}
+var farmPort = () => Number(process.env.FARM_PORT) || 5173;
+
+export {
+  cliApp,
+  farmPort
+};