@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/serve-XT32MAEN.js

@@ -0,0 +1,1687 @@
+import {
+  startPolicyWatch
+} from "./chunk-PYZWMVJ6.js";
+import {
+  checkPolicyScreen,
+  policyScreens
+} from "./chunk-WTTCWFOX.js";
+import {
+  addIgnore,
+  askClaude,
+  farmScenarios,
+  readAllPageRules,
+  readFigmaCache,
+  readFrontFigmaMap,
+  readIgnores,
+  removeIgnore
+} from "./chunk-VGPCTMUA.js";
+import {
+  startCollectors
+} from "./chunk-ZE2GGXFO.js";
+import {
+  ExploreRequestError,
+  FrameRing,
+  LogRing,
+  baselineKey,
+  channelTolerance,
+  closeUnfinishedRun,
+  confirmDeviceBaselines,
+  createRunId,
+  defaultGuard,
+  deviceBaselinesRoot,
+  devicesRoot,
+  errorMessage,
+  installedVersionLabel,
+  loadExploreInputs,
+  pendingDeviceBaselines,
+  probeScreen,
+  pruneRuns,
+  readLatestExplore,
+  readLatestRun,
+  replayOne,
+  runDevices,
+  runExplore,
+  testResultsRoot,
+  writeRun
+} from "./chunk-AVECSGEH.js";
+import "./chunk-UAHWEUDI.js";
+import "./chunk-F6PZOBU6.js";
+import "./chunk-Q6CXF3NJ.js";
+import {
+  acceptGenerated,
+  addCandidate,
+  confirmFlows,
+  flowDirs,
+  listPrds,
+  mapFlowError,
+  mapFlowPrd,
+  mapRulesOf,
+  prdHash,
+  prdRoot,
+  readCandidates,
+  readHashes,
+  readPrd,
+  readReady,
+  writeCandidates,
+  writeHash
+} from "./chunk-PLMSQ5KF.js";
+import {
+  readScreenMap,
+  recordScreenMap
+} from "./chunk-F4TMB4WY.js";
+import {
+  stepsOf
+} from "./chunk-SWW42KTA.js";
+import {
+  runScreenQa
+} from "./chunk-3GCH6TN3.js";
+import {
+  createDeviceDeps,
+  createDeviceList,
+  defaultBuildDeps,
+  firebaseAppId,
+  listReleases,
+  pickRelease
+} from "./chunk-PZZQWRSU.js";
+import "./chunk-OUNLQI2N.js";
+import {
+  closeAllIosSessions,
+  getIosSession,
+  iosMjpegPort,
+  isDeadSessionError,
+  resetIosSession
+} from "./chunk-S6GHOP4B.js";
+import "./chunk-JZDYF3HL.js";
+import {
+  cliApp
+} from "./chunk-7OJDY276.js";
+import {
+  execFileText,
+  nativeContext
+} from "./chunk-AXQNUPGC.js";
+import {
+  apiOrigin,
+  loadDotEnv,
+  webOrigin
+} from "./chunk-NLX3V7ZJ.js";
+import {
+  appIdFor,
+  publicAppConfig,
+  tabNamesOf
+} from "./chunk-NJNTEWXE.js";
+
+// apps/cli/src/serve.ts
+import { existsSync as existsSync3 } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+import { preview } from "vite";
+
+// packages/server/src/http/device-api.ts
+import { readFileSync as readFileSync4, realpathSync, statSync } from "fs";
+import { get as httpGet } from "http";
+import path5 from "path";
+import { WebSocket, WebSocketServer } from "ws";
+
+// packages/core/src/device/input.ts
+var inputKeys = ["back", "home"];
+var maxSwipeMs = 1e4;
+var maxTextLength = 1e3;
+function clamp(value, max) {
+  return Math.min(Math.max(value, 0), max);
+}
+function toDevicePoint(point, size) {
+  return {
+    x: clamp(Math.round(point.x * size.width), size.width - 1),
+    y: clamp(Math.round(point.y * size.height), size.height - 1)
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parsePoint(value) {
+  if (!isRecord(value) || !isFiniteNumber(value.x) || !isFiniteNumber(value.y)) return null;
+  return { x: value.x, y: value.y };
+}
+function parseSwipe(value) {
+  const from = parsePoint(value.from);
+  const to = parsePoint(value.to);
+  const { durationMs } = value;
+  if (!from || !to || !isFiniteNumber(durationMs) || durationMs < 0 || durationMs > maxSwipeMs) return null;
+  return { type: "swipe", from, to, durationMs };
+}
+function parseKey(value) {
+  return inputKeys.find((key) => key === value) ?? null;
+}
+function parseInputEvent(value) {
+  if (!isRecord(value)) return null;
+  if (value.type === "tap") {
+    const point = parsePoint(value);
+    return point ? { type: "tap", ...point } : null;
+  }
+  if (value.type === "swipe") return parseSwipe(value);
+  if (value.type === "text") {
+    const { text } = value;
+    return typeof text === "string" && text.length > 0 && text.length <= maxTextLength ? { type: "text", text } : null;
+  }
+  if (value.type === "key") {
+    const key = parseKey(value.key);
+    return key ? { type: "key", key } : null;
+  }
+  return null;
+}
+
+// packages/devices/src/stream/ios.ts
+var iosMjpegUrl = `http://127.0.0.1:${iosMjpegPort}`;
+var iosBackUnsupported = "iOS\uB294 \uB4A4\uB85C \uD0A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.";
+var tapHoldMs = 50;
+var fingerId = "finger1";
+var moveTo = (point, duration) => ({ type: "pointerMove", duration, origin: "viewport", ...point });
+function iosTapArgs(event, size) {
+  return event.type === "tap" ? toDevicePoint(event, size) : null;
+}
+function iosPointerActions(event, size) {
+  const touch2 = (steps) => [
+    { type: "pointer", id: fingerId, parameters: { pointerType: "touch" }, actions: steps }
+  ];
+  if (event.type === "tap") {
+    const point = toDevicePoint(event, size);
+    return touch2([moveTo(point, 0), { type: "pointerDown", button: 0 }, { type: "pause", duration: tapHoldMs }, { type: "pointerUp", button: 0 }]);
+  }
+  if (event.type === "swipe") {
+    const from = toDevicePoint(event.from, size);
+    const to = toDevicePoint(event.to, size);
+    return touch2([moveTo(from, 0), { type: "pointerDown", button: 0 }, moveTo(to, Math.round(event.durationMs)), { type: "pointerUp", button: 0 }]);
+  }
+  return null;
+}
+async function sendKey(session, key) {
+  if (key === "back") throw new Error(iosBackUnsupported);
+  await session.execute("mobile: pressButton", { name: "home" });
+}
+async function openIosStream(udid, session) {
+  await session.switchContext(nativeContext);
+  const window = await session.getWindowSize();
+  const size = { width: window.width, height: window.height };
+  const send = async (event) => {
+    if (event.type === "key") return sendKey(session, event.key);
+    const tap = iosTapArgs(event, size);
+    if (tap) return void await session.execute("mobile: tap", tap);
+    await session.switchContext(nativeContext);
+    if (event.type === "text") return session.keys(event.text);
+    const actions = iosPointerActions(event, size);
+    if (!actions) throw new Error(`${udid}: \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC785\uB825\uC785\uB2C8\uB2E4.`);
+    await session.performActions(actions);
+  };
+  return {
+    mjpegUrl: iosMjpegUrl,
+    send,
+    size: () => size,
+    // 세션은 상시 유지한다. 닫을 것은 없다.
+    close: async () => void 0
+  };
+}
+
+// packages/engine/src/chaos/results.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import path from "path";
+var chaosRoot = path.resolve("test-results/chaos");
+var runIdPattern = /^[0-9A-Za-z-]+$/;
+function readChaosRun(runId, root = chaosRoot) {
+  if (!runIdPattern.test(runId)) return null;
+  const file = path.join(root, runId, "run.json");
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listChaosRuns(root = chaosRoot) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root).flatMap((runId) => {
+    const run = readChaosRun(runId, root);
+    if (!run) return [];
+    const summary = {
+      runId: run.runId,
+      deviceId: run.deviceId,
+      seed: run.seed,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt,
+      steps: run.steps.length,
+      states: run.states,
+      errorSteps: run.steps.filter((step) => step.errors.length > 0).length,
+      blocked: run.blocked.length
+    };
+    return [summary];
+  }).sort((a, b) => a.startedAt < b.startedAt ? 1 : -1);
+}
+
+// packages/core/src/flows/prompt.ts
+function parseModelJson(text) {
+  const trimmed = text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+  try {
+    const parsed = JSON.parse(trimmed);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function generationPrompt(input2) {
+  const tabNames = tabNamesOf(input2.app);
+  const forbiddenClickNames = input2.app.guard.forbiddenClickNames;
+  return [
+    `PRD\uC5D0\uC11C ${input2.app.name} \uC571 \uC2E4\uAE30\uAE30 \uD50C\uB85C\uC6B0 \uC810\uAC80 \uD6C4\uBCF4\uB97C JSON \uBC30\uC5F4\uB85C\uB9CC \uB2F5\uD55C\uB2E4.`,
+    "\uB3D9\uC791\uC740 click, expectText\uB9CC \uC4F4\uB2E4. \uC8FC\uC18C\uB85C \uD654\uBA74\uC744 \uC5EC\uB294 \uB3D9\uC791\uC740 \uC5C6\uB2E4.",
+    `\uD50C\uB85C\uC6B0\uB294 \uC571 \uD648(${input2.app.homeTabName} \uD0ED)\uC5D0\uC11C \uC2DC\uC791\uD55C\uB2E4. \uC810\uAC80\uAE30\uAC00 \uC2DC\uC791 \uC804\uC5D0 \uD648\uC73C\uB85C \uBCF4\uB0B8\uB2E4. \uB2E4\uB978 \uD654\uBA74\uC73C\uB85C\uB294 \uBC84\uD2BC\uACFC \uB9C1\uD06C\uB97C \uB20C\uB7EC\uC11C\uB9CC \uAC04\uB2E4.`,
+    `\uD558\uB2E8 \uD0ED\uC740 click.target.role link\uB85C \uB204\uB978\uB2E4. \uD0ED \uC774\uB984: ${tabNames.join(", ")}.`,
+    "click.target.role\uC740 button \uB610\uB294 link\uC774\uACE0 name\uC740 \uD654\uBA74\uC5D0 \uBCF4\uC774\uB294 \uBB38\uAD6C\uC640 \uC815\uD655\uD788 \uAC19\uC544\uC57C \uD55C\uB2E4.",
+    "click \uB4A4\uC5D0\uB294 \uBC14\uB010 \uD654\uBA74\uC758 \uBB38\uAD6C\uB97C expectText\uB85C \uD655\uC778\uD55C\uB2E4.",
+    `${forbiddenClickNames.join(", ")} \uBC84\uD2BC\uC740 \uC4F0\uC9C0 \uC54A\uB294\uB2E4.`,
+    "\uC785\uB825, \uC8FC\uBB38, \uACB0\uC81C, \uD310\uB9E4, \uCD9C\uAE08, \uD0C8\uD1F4, \uBCF8\uC778\uC778\uC99D \uD50C\uB85C\uC6B0\uB294 \uB9CC\uB4E4\uC9C0 \uC54A\uB294\uB2E4.",
+    "expectText\uAC00 \uD558\uB098 \uC774\uC0C1 \uC788\uC5B4\uC57C \uD55C\uB2E4.",
+    "requirement\uB294 PRD\uC5D0 \uC788\uB294 \uBB38\uC7A5\uC744 \uADF8\uB300\uB85C \uC4F4\uB2E4.",
+    "proposal\uC740 keep, update, create, delete \uC911 \uD558\uB098\uB2E4.",
+    "id\uB294 \uC601\uBB38 \uC18C\uBB38\uC790\uC640 \uC22B\uC790, \uD558\uC774\uD508\uB9CC \uC4F4\uB2E4.",
+    "source\uB294 ai_generated\uB2E4.",
+    `PRD \uD30C\uC77C: ${input2.prdName}`,
+    "\uD655\uC815\uB41C \uC2DC\uB098\uB9AC\uC624:",
+    JSON.stringify(input2.ready.map((item) => ({ id: item.id, name: item.name, requirement: item.requirement, steps: item.steps }))),
+    "PRD \uBCF8\uBB38:",
+    input2.prdBody
+  ].join("\n");
+}
+
+// packages/engine/src/flows/llm.ts
+var llmTimeoutMs = 2e4;
+function llmConfigured() {
+  return Boolean(process.env.FLOW_LLM_API_KEY && process.env.FLOW_LLM_BASE_URL && process.env.FLOW_LLM_MODEL);
+}
+async function complete(prompt) {
+  const key = process.env.FLOW_LLM_API_KEY ?? "";
+  const base = process.env.FLOW_LLM_BASE_URL ?? "";
+  const model = process.env.FLOW_LLM_MODEL ?? "";
+  if (!key || !base || !model) return { ok: false, skipped: true };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), llmTimeoutMs);
+  try {
+    const response = await fetch(new URL("chat/completions", base.endsWith("/") ? base : `${base}/`), {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${key}` },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }]
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) return { ok: false, skipped: false };
+    const body = await response.json();
+    const text = body.choices?.[0]?.message?.content;
+    if (typeof text !== "string" || !text) return { ok: false, skipped: false };
+    return { ok: true, text };
+  } catch {
+    return { ok: false, skipped: false };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// packages/engine/src/flows/generate.ts
+var llmMissingReason = "FLOW_LLM_API_KEY\xB7FLOW_LLM_BASE_URL\xB7FLOW_LLM_MODEL\uC774 \uC5C6\uC5B4 \uC0DD\uC131\uC744 \uAC74\uB108\uB701\uB2C8\uB2E4.";
+var sameHashReason = "PRD\uAC00 \uC9C0\uB09C \uC0DD\uC131 \uB4A4 \uBC14\uB00C\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.";
+async function generateFromPrd(app, name, dirs = flowDirs, llm = complete) {
+  const body = readPrd(name);
+  if (body == null) return { ok: false, status: 400, error: `PRD\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${name}` };
+  const hash = prdHash(body);
+  if (readHashes(dirs)[name] === hash) return { ok: true, generated: 0, skipped: true, reason: sameHashReason };
+  if (llm === complete && !llmConfigured()) return { ok: true, generated: 0, skipped: true, reason: llmMissingReason };
+  const result = await llm(generationPrompt({ app, prdName: name, prdBody: body, ready: readReady(dirs) }));
+  if (!result.ok) return { ok: false, status: 502, error: "LLM\uC774 \uB2F5\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4." };
+  const items = parseModelJson(result.text);
+  if (!items) return { ok: false, status: 502, error: "LLM \uB2F5\uC774 JSON \uBC30\uC5F4\uC774 \uC544\uB2D9\uB2C8\uB2E4." };
+  const accepted = acceptGenerated(items, name, body, app.guard.forbiddenClickNames, dirs);
+  writeCandidates(name, accepted, dirs);
+  writeHash(name, hash, dirs);
+  return { ok: true, generated: accepted.length, skipped: false };
+}
+
+// packages/server/src/access.ts
+var localUser = "local";
+var userHeader = "tailscale-user-login";
+var proxyHeaders = ["x-forwarded-for", "x-forwarded-host", "forwarded", "tailscale-user-name"];
+var loopbackAddresses = ["127.0.0.1", "::1", "::ffff:127.0.0.1"];
+function allowedDomains(value = process.env.FARM_ALLOWED_DOMAINS, fallback = []) {
+  const normalize = (list) => list.map((domain) => domain.trim().toLowerCase().replace(/^@/, "")).filter(Boolean);
+  const domains = normalize((value ?? "").split(","));
+  return domains.length > 0 ? domains : normalize(fallback);
+}
+function headerValue(headers, name) {
+  const value = headers[name];
+  return (Array.isArray(value) ? value[0] : value)?.trim() || void 0;
+}
+function domainOf(login) {
+  return (login.split("@").at(-1) ?? "").toLowerCase();
+}
+function decideAccess(input2, domains) {
+  const login = headerValue(input2.headers, userHeader);
+  if (login) {
+    if (login.includes("@") && domains.includes(domainOf(login))) return { ok: true, user: login };
+    const allowed = domains.length > 0 ? `${domains.join(", ")} \uACC4\uC815\uC73C\uB85C \uC811\uC18D\uD574 \uC8FC\uC138\uC694.` : "\uD5C8\uC6A9\uD55C \uACC4\uC815 \uB3C4\uBA54\uC778\uC774 \uC5C6\uC2B5\uB2C8\uB2E4(FARM_ALLOWED_DOMAINS\xB7access.allowedDomains).";
+    return { ok: false, status: 403, message: `${login} \uACC4\uC815\uC740 \uB514\uBC14\uC774\uC2A4\uD31C\uC744 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. ${allowed}` };
+  }
+  const proxied = proxyHeaders.some((name) => headerValue(input2.headers, name));
+  const loopback = loopbackAddresses.some((address) => address === input2.remoteAddress);
+  if (loopback && !proxied) return { ok: true, user: localUser };
+  return { ok: false, status: 401, message: "Tailscale \uACC4\uC815\uC744 \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. tailnet \uC548\uC5D0\uC11C tailscale serve \uC8FC\uC18C\uB85C \uC811\uC18D\uD574 \uC8FC\uC138\uC694." };
+}
+
+// packages/core/src/device/lock.ts
+var controlIdleMs = 5 * 6e4;
+function sameOwner(left, right) {
+  if (left.kind === "bot" && right.kind === "bot") return left.runId === right.runId;
+  if (left.kind === "user" && right.kind === "user") return left.user === right.user;
+  return false;
+}
+var DeviceLocks = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  entries = /* @__PURE__ */ new Map();
+  acquire(id, owner) {
+    const current = this.ownerOf(id);
+    if (current && !sameOwner(current, owner)) return false;
+    this.entries.set(id, { owner, touchedAt: this.now() });
+    return true;
+  }
+  release(id, owner) {
+    const current = this.ownerOf(id);
+    if (current && sameOwner(current, owner)) this.entries.delete(id);
+  }
+  touch(id) {
+    const entry = this.entries.get(id);
+    if (entry) entry.touchedAt = this.now();
+  }
+  ownerOf(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return null;
+    const idle = entry.owner.kind === "user" && this.now() - entry.touchedAt > controlIdleMs;
+    if (!idle) return entry.owner;
+    this.entries.delete(id);
+    return null;
+  }
+};
+
+// packages/server/src/baselines.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path2 from "path";
+import { PNG } from "pngjs";
+var keyHashLength = 16;
+var fadeRatio = 0.3;
+var channelMax = 255;
+function baselineDir(key, root) {
+  const id = createHash("sha256").update(key, "utf8").digest("hex").slice(0, keyHashLength);
+  return path2.join(root, id);
+}
+function candidatePng(key, root = deviceBaselinesRoot) {
+  if (!pendingDeviceBaselines(root).includes(key)) return null;
+  const file = path2.join(baselineDir(key, root), "candidate.png");
+  return existsSync2(file) ? readFileSync2(file) : null;
+}
+function differs(left, right, offset) {
+  for (let channel = 0; channel < 3; channel += 1) {
+    if (Math.abs(left[offset + channel] - right[offset + channel]) > channelTolerance) return true;
+  }
+  return false;
+}
+function diffPng(current, baseline) {
+  const now = PNG.sync.read(current);
+  const base = PNG.sync.read(baseline);
+  if (now.width !== base.width || now.height !== base.height) return null;
+  const out = new PNG({ width: now.width, height: now.height });
+  for (let offset = 0; offset < now.data.length; offset += 4) {
+    const red = differs(now.data, base.data, offset);
+    for (let channel = 0; channel < 3; channel += 1) {
+      const faded = channelMax - (channelMax - now.data[offset + channel]) * fadeRatio;
+      out.data[offset + channel] = red ? channel === 0 ? channelMax : 0 : Math.round(faded);
+    }
+    out.data[offset + 3] = channelMax;
+  }
+  return PNG.sync.write(out);
+}
+function baselineFor(device, scenario, screenshot, root = deviceBaselinesRoot) {
+  const file = path2.join(baselineDir(baselineKey(device, scenario.name), root), "baseline.png");
+  if (!existsSync2(file)) return void 0;
+  const baseline = readFileSync2(file);
+  const diff = diffPng(screenshot, baseline);
+  return diff ? { baseline, diff } : void 0;
+}
+
+// packages/server/src/auto.ts
+function createAutoRuns(deps) {
+  async function platformDevices(signal) {
+    return (await deps.connected()).filter((device) => device.platform === signal.target.platform);
+  }
+  async function runAuto(signal) {
+    const { platform, kind } = signal.target;
+    const ids = (await platformDevices(signal)).map((device) => device.id);
+    if (ids.length === 0) {
+      deps.log(`${platform}-${kind} ${signal.version} \uC790\uB3D9 \uC810\uAC80: \uC5F0\uACB0\uB41C \uAE30\uAE30\uAC00 \uC5C6\uC5B4 \uAC74\uB108\uB701\uB2C8\uB2E4.`);
+      return;
+    }
+    await deps.gate.startWhenIdle("run", () => runDevices({ kind, version: signal.version, deviceIds: ids, trigger: "auto" }, deps.runDeps()));
+  }
+  async function failIos(signal, message) {
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const ios = await platformDevices(signal);
+    deps.record({
+      runId: createRunId(Date.now()),
+      kind: signal.target.kind,
+      version: signal.version,
+      trigger: "auto",
+      startedAt: at,
+      finishedAt: at,
+      outcomes: ios.map((device) => ({ device, status: "install_failed", message, screens: [] }))
+    });
+  }
+  return { runAuto, failIos };
+}
+
+// packages/server/src/capture.ts
+function createCapture(hub) {
+  return async (device, driver, appId) => {
+    const ring = new LogRing();
+    const frames = new FrameRing();
+    const stopCollectors = await startCollectors(device, appId, driver, ring);
+    let unsubscribe = () => {
+    };
+    if (device.platform === "android") {
+      try {
+        const subscription = await hub.subscribe(device.id, (packet, key) => frames.push(Buffer.from(packet), Date.now(), key));
+        unsubscribe = subscription.unsubscribe;
+      } catch (error) {
+        ring.push({ source: "system", text: `\uC601\uC0C1 \uC218\uC9D1 \uC2E4\uD328: ${errorMessage(error)}` });
+      }
+    }
+    return {
+      ring,
+      frames: () => frames.frames(),
+      stop: async () => {
+        unsubscribe();
+        frames.clear();
+        await stopCollectors();
+      }
+    };
+  };
+}
+
+// packages/server/src/control.ts
+import { appendFileSync, mkdirSync } from "fs";
+import path3 from "path";
+var controlFile = path3.join(devicesRoot, "control.jsonl");
+var expireCheckMs = 3e4;
+function createControlLog(locks, file = controlFile, now = Date.now) {
+  const held = /* @__PURE__ */ new Map();
+  function append(entry) {
+    mkdirSync(path3.dirname(file), { recursive: true });
+    appendFileSync(file, `${JSON.stringify(entry)}
+`);
+  }
+  function record(entry) {
+    if (entry.action === "lock") held.set(entry.deviceId, entry.user);
+    else held.delete(entry.deviceId);
+    append({ at: now(), ...entry });
+  }
+  function checkExpired() {
+    for (const [deviceId, user] of held) {
+      const owner = locks.ownerOf(deviceId);
+      if (owner?.kind === "user" && owner.user === user) continue;
+      record({ user, deviceId, action: "expire" });
+    }
+  }
+  const timer = setInterval(checkExpired, expireCheckMs);
+  timer.unref();
+  return { record, checkExpired, stop: () => clearInterval(timer) };
+}
+
+// packages/server/src/jobs.ts
+import { setTimeout as wait } from "timers/promises";
+var busyMessages = {
+  run: "\uC774\uBBF8 \uAE30\uAE30 \uC810\uAC80 \uC911\uC785\uB2C8\uB2E4.",
+  explore: "\uC774\uBBF8 \uD0D0\uC0C9 \uC911\uC785\uB2C8\uB2E4.",
+  replay: "\uB2E4\uC2DC \uB3CC\uB9AC\uAE30\uAC00 \uC9C4\uD589 \uC911\uC785\uB2C8\uB2E4."
+};
+var idlePollMs = 1e3;
+function createJobGate(onIdle) {
+  let current = null;
+  function start(kind, work) {
+    if (current !== null) return null;
+    current = kind;
+    return (async () => {
+      try {
+        await work();
+      } finally {
+        current = null;
+        onIdle();
+      }
+    })();
+  }
+  async function startWhenIdle(kind, work) {
+    for (; ; ) {
+      const started = start(kind, work);
+      if (started) return started;
+      await wait(idlePollMs);
+    }
+  }
+  return {
+    start,
+    startWhenIdle,
+    isBusy: () => current !== null,
+    busyMessage: () => current === null ? "" : busyMessages[current]
+  };
+}
+
+// packages/devices/src/stream/android.ts
+import { spawn } from "child_process";
+import { setTimeout as wait2 } from "timers/promises";
+var screenrecordBitRate = 4e6;
+var screenrecordTimeLimitSec = 180;
+var restartDelayMs = 1e3;
+var nalTypeMask = 31;
+var nalTypes = { idr: 5, sps: 7, pps: 8 };
+var firstVclType = 1;
+var lastVclType = 5;
+var startCode = Uint8Array.of(0, 0, 0, 1);
+var startCodeLength = startCode.length;
+var androidKeyCodes = { back: 4, home: 3 };
+function concatBytes(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function parseWmSize(stdout) {
+  const pick = (label) => stdout.match(new RegExp(`${label} size:\\s*(\\d+)x(\\d+)`));
+  const match = pick("Override") ?? pick("Physical");
+  if (!match) return null;
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+function avcCodecString(sps) {
+  const hex = (byte) => byte.toString(16).toUpperCase().padStart(2, "0");
+  const header = startCodeLength;
+  return `avc1.${hex(sps[header + 1])}${hex(sps[header + 2])}${hex(sps[header + 3])}`;
+}
+function nalType(nal) {
+  return nal[startCodeLength] & nalTypeMask;
+}
+function findNalStarts(buffer) {
+  const starts = [];
+  for (let index = 0; index + 2 < buffer.length; index += 1) {
+    if (buffer[index] === 0 && buffer[index + 1] === 0 && buffer[index + 2] === 1) {
+      starts.push(index + 3);
+      index += 2;
+    }
+  }
+  return starts;
+}
+function withStartCode(payload) {
+  let end = payload.length;
+  while (end > 0 && payload[end - 1] === 0) end -= 1;
+  return concatBytes([startCode, payload.subarray(0, end)]);
+}
+var AnnexBSplitter = class {
+  buffer = new Uint8Array(0);
+  push(chunk) {
+    this.buffer = concatBytes([this.buffer, chunk]);
+    const starts = findNalStarts(this.buffer);
+    if (starts.length < 2) return [];
+    const nals = starts.slice(0, -1).map((start, index) => withStartCode(this.buffer.subarray(start, starts[index + 1] - 3)));
+    this.buffer = this.buffer.slice(starts[starts.length - 1] - 3);
+    return nals;
+  }
+};
+var AccessUnitAssembler = class {
+  pending = [];
+  sps = null;
+  pps = null;
+  latestSps() {
+    return this.sps;
+  }
+  push(nal) {
+    const type = nalType(nal);
+    if (type === nalTypes.sps) this.sps = nal;
+    if (type === nalTypes.pps) this.pps = nal;
+    this.pending.push(nal);
+    if (type < firstVclType || type > lastVclType) return null;
+    const parts = this.pending;
+    this.pending = [];
+    const key = type === nalTypes.idr;
+    return { packet: concatBytes(key ? this.withParameterSets(parts) : parts), key };
+  }
+  withParameterSets(parts) {
+    const has = (wanted) => parts.some((part) => nalType(part) === wanted);
+    const prefix = [!has(nalTypes.sps) ? this.sps : null, !has(nalTypes.pps) ? this.pps : null].filter(
+      (part) => part !== null
+    );
+    return [...prefix, ...parts];
+  }
+};
+var printableAscii = /^[\x20-\x7e]+$/;
+function escapeInputText(text) {
+  if (!printableAscii.test(text)) throw new Error("Android \uC9C1\uC811 \uC785\uB825\uC740 \uC601\uBB38\xB7\uC22B\uC790\xB7\uAE30\uD638\uB9CC \uB429\uB2C8\uB2E4.");
+  const spaced = text.replace(/ /g, "%s");
+  return `'${spaced.replace(/'/g, "'\\''")}'`;
+}
+function androidInputArgs(serial, event, size) {
+  const shell = ["-s", serial, "shell", "input"];
+  if (event.type === "tap") {
+    const point = toDevicePoint(event, size);
+    return [...shell, "tap", String(point.x), String(point.y)];
+  }
+  if (event.type === "swipe") {
+    const from = toDevicePoint(event.from, size);
+    const to = toDevicePoint(event.to, size);
+    return [...shell, "swipe", ...[from.x, from.y, to.x, to.y, Math.round(event.durationMs)].map(String)];
+  }
+  if (event.type === "text") return [...shell, "text", escapeInputText(event.text)];
+  return [...shell, "keyevent", String(androidKeyCodes[event.key])];
+}
+function screenrecordArgs(serial) {
+  return [
+    "-s",
+    serial,
+    "exec-out",
+    "screenrecord",
+    "--output-format=h264",
+    "--bit-rate",
+    String(screenrecordBitRate),
+    "--time-limit",
+    String(screenrecordTimeLimitSec),
+    "-"
+  ];
+}
+async function readScreenSize(serial, exec) {
+  const stdout = await exec("adb", ["-s", serial, "shell", "wm", "size"]);
+  const size = parseWmSize(stdout);
+  if (!size) throw new Error(`${serial} \uD654\uBA74 \uD06C\uAE30\uB97C \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.`);
+  return size;
+}
+var defaultSpawnRecorder = (args) => spawn("adb", args, { stdio: ["ignore", "pipe", "ignore"] });
+async function openAndroidStream(serial, deps = {}) {
+  const exec = deps.exec ?? execFileText;
+  const spawnRecorder = deps.spawnRecorder ?? defaultSpawnRecorder;
+  const size = await readScreenSize(serial, exec);
+  const listeners = [];
+  const assembler = new AccessUnitAssembler();
+  let recorder = null;
+  let closed = false;
+  const emit = (nal) => {
+    const video = assembler.push(nal);
+    if (video) for (const listener of listeners) listener(video.packet, video.key);
+  };
+  const start = () => {
+    const splitter = new AnnexBSplitter();
+    const child = spawnRecorder(screenrecordArgs(serial));
+    recorder = child;
+    child.stdout.on("data", (chunk) => splitter.push(chunk).forEach(emit));
+    let ended = false;
+    const restart = async () => {
+      if (ended || closed) return;
+      ended = true;
+      await wait2(restartDelayMs);
+      if (!closed) start();
+    };
+    child.on("error", restart);
+    child.on("close", restart);
+  };
+  start();
+  return {
+    onVideo: (cb) => {
+      listeners.push(cb);
+    },
+    send: async (event) => {
+      await exec("adb", androidInputArgs(serial, event, size));
+    },
+    size: () => size,
+    codec: () => {
+      const sps = assembler.latestSps();
+      return sps ? avcCodecString(sps) : null;
+    },
+    close: async () => {
+      closed = true;
+      recorder?.kill("SIGTERM");
+      recorder = null;
+    }
+  };
+}
+
+// packages/server/src/streams.ts
+var defaultOpenIos = (app) => async (udid) => {
+  if (!app) throw new Error("\uC571 \uC124\uC815 \uC5C6\uC774 iOS \uC2A4\uD2B8\uB9BC\uC744 \uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  return openIosStream(udid, await getIosSession(udid, appIdFor(app, "dev", "ios"), app.ios));
+};
+function createStreamHub(deps = {}) {
+  const openAndroid = deps.openAndroid ?? ((serial) => openAndroidStream(serial));
+  const openIos = deps.openIos ?? defaultOpenIos(deps.app);
+  const android = /* @__PURE__ */ new Map();
+  const ios = /* @__PURE__ */ new Map();
+  function entryOf(serial) {
+    const existing = android.get(serial);
+    if (existing) return existing;
+    const listeners = /* @__PURE__ */ new Set();
+    const stream = openAndroid(serial).then((opened) => {
+      opened.onVideo((packet, key) => listeners.forEach((listener) => listener(packet, key)));
+      return opened;
+    });
+    const entry = { stream, listeners };
+    android.set(serial, entry);
+    stream.catch(() => {
+      if (android.get(serial) === entry) android.delete(serial);
+    });
+    return entry;
+  }
+  async function subscribe(serial, listener) {
+    const entry = entryOf(serial);
+    entry.listeners.add(listener);
+    let stream;
+    try {
+      stream = await entry.stream;
+    } catch (error) {
+      entry.listeners.delete(listener);
+      throw error;
+    }
+    const unsubscribe = () => {
+      if (!entry.listeners.delete(listener) || entry.listeners.size > 0) return;
+      if (android.get(serial) === entry) android.delete(serial);
+      void stream.close();
+    };
+    return { stream, unsubscribe };
+  }
+  function iosStream(udid) {
+    const existing = ios.get(udid);
+    if (existing) return existing;
+    const opening = openIos(udid);
+    ios.set(udid, opening);
+    opening.catch(() => {
+      if (ios.get(udid) === opening) ios.delete(udid);
+    });
+    return opening;
+  }
+  async function sendAndroid(serial, event) {
+    const { stream, unsubscribe } = await subscribe(serial, () => void 0);
+    try {
+      await stream.send(event);
+    } finally {
+      unsubscribe();
+    }
+  }
+  return {
+    subscribe,
+    sendAndroid,
+    sendIos: async (udid, event) => {
+      try {
+        await (await iosStream(udid)).send(event);
+      } catch (error) {
+        if (!isDeadSessionError(error)) throw error;
+        ios.delete(udid);
+        await resetIosSession(udid);
+        await (await iosStream(udid)).send(event);
+      }
+    },
+    /** 앱 재설치로 Appium 세션을 새로 열었을 때. 다음 입력이 새 세션으로 스트림을 연다. */
+    forgetIos: (udid) => {
+      ios.delete(udid);
+    }
+  };
+}
+async function watchVideo(hub, serial, sink) {
+  let stream = null;
+  let sentHeader = false;
+  const subscription = await hub.subscribe(serial, (packet, key) => {
+    if (!sentHeader) {
+      const codec = stream?.codec();
+      if (!key || !stream || !codec) return;
+      sink.header({ codec, ...stream.size() });
+      sentHeader = true;
+    }
+    sink.packet(packet);
+  });
+  stream = subscription.stream;
+  return subscription.unsubscribe;
+}
+
+// packages/server/src/build/testflight.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { sign } from "crypto";
+var ascTokenTtlSeconds = 20 * 60;
+var ascAudience = "appstoreconnect-v1";
+var ascBuildsUrl = "https://api.appstoreconnect.apple.com/v1/builds";
+var ascBuildsLimit = 20;
+function requireEnv(name) {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(`${name}\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.`);
+  return value;
+}
+function ascKeyFromEnv() {
+  return {
+    keyId: requireEnv("ASC_KEY_ID"),
+    issuerId: requireEnv("ASC_ISSUER_ID"),
+    privateKey: readFileSync3(requireEnv("ASC_PRIVATE_KEY_PATH"), "utf8")
+  };
+}
+function ascAppId(kind = "prod") {
+  return requireEnv(kind === "dev" ? "ASC_APP_ID_DEV" : "ASC_APP_ID");
+}
+function base64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function ascToken(now, key = ascKeyFromEnv()) {
+  const iat = Math.floor(now / 1e3);
+  const header = base64UrlJson({ alg: "ES256", kid: key.keyId, typ: "JWT" });
+  const payload = base64UrlJson({ iss: key.issuerId, iat, exp: iat + ascTokenTtlSeconds, aud: ascAudience });
+  const signingInput = `${header}.${payload}`;
+  const signature = sign("sha256", Buffer.from(signingInput), { key: key.privateKey, dsaEncoding: "ieee-p1363" });
+  return `${signingInput}.${signature.toString("base64url")}`;
+}
+function ascFetchJson(now = Date.now) {
+  return async (url) => {
+    const response = await fetch(url, { headers: { Authorization: `Bearer ${ascToken(now())}` } });
+    if (!response.ok) throw new Error(`App Store Connect HTTP ${response.status}`);
+    return response.json();
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function field(value, ...keys) {
+  return keys.reduce((current, key) => isRecord2(current) ? current[key] : void 0, value);
+}
+function preReleaseVersions(included) {
+  const versions = /* @__PURE__ */ new Map();
+  if (!Array.isArray(included)) return versions;
+  for (const item of included) {
+    const id = field(item, "id");
+    const version = field(item, "attributes", "version");
+    if (field(item, "type") === "preReleaseVersions" && typeof id === "string" && typeof version === "string") {
+      versions.set(id, version);
+    }
+  }
+  return versions;
+}
+function toBuild(item, versions) {
+  const id = field(item, "id");
+  const build = field(item, "attributes", "version");
+  const uploadedDate = field(item, "attributes", "uploadedDate");
+  const preReleaseId = field(item, "relationships", "preReleaseVersion", "data", "id");
+  const version = typeof preReleaseId === "string" ? versions.get(preReleaseId) : void 0;
+  if (typeof id !== "string" || typeof build !== "string" || typeof uploadedDate !== "string" || !version) return null;
+  return { id, version, build, uploadedDate };
+}
+async function listTestflightBuilds(fetchJson, appId) {
+  const query = `filter[app]=${encodeURIComponent(appId)}&sort=-uploadedDate&limit=${ascBuildsLimit}&include=preReleaseVersion`;
+  const body = await fetchJson(`${ascBuildsUrl}?${query}`);
+  const data = field(body, "data");
+  if (!Array.isArray(data)) throw new Error("App Store Connect \uBE4C\uB4DC \uBAA9\uB85D \uC751\uB2F5 \uD615\uC2DD\uC774 \uB2E4\uB985\uB2C8\uB2E4.");
+  const versions = preReleaseVersions(field(body, "included"));
+  return data.map((item) => toBuild(item, versions)).filter((build) => build !== null);
+}
+
+// packages/server/src/build/watch.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path4 from "path";
+var releasePollMs = 5 * 6e4;
+var adhocWaitMs = 60 * 6e4;
+var seenFile = "test-results/devices/seen-releases.json";
+var emptySeen = "";
+var watchTargets = [
+  { platform: "android", kind: "dev" },
+  { platform: "android", kind: "prod" },
+  { platform: "ios", kind: "dev" },
+  { platform: "ios", kind: "prod" }
+];
+function targetKey(target) {
+  return `${target.platform}-${target.kind}`;
+}
+function newestUnseen(items, seen) {
+  const newest = items[0];
+  return newest && newest.id !== seen ? newest : null;
+}
+function releaseSignals(target, releases) {
+  return [...releases].sort((a, b) => Date.parse(b.createTime) - Date.parse(a.createTime)).map((release) => ({ target, id: release.name, version: `${release.displayVersion}+${release.buildVersion}` }));
+}
+function testflightSignals(target, builds) {
+  return builds.map((build) => ({ target, id: build.id, version: `${build.version}+${build.build}` }));
+}
+function adhocMissingMessage(version) {
+  return `${version} TestFlight \uBE4C\uB4DC\uC640 \uAC19\uC740 Ad-hoc\uC774 Firebase\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.`;
+}
+function isIosProd(target) {
+  return target.platform === "ios" && target.kind === "prod";
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parseSeen(text) {
+  const value = JSON.parse(text);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+async function readSeen(filePath, log) {
+  try {
+    return parseSeen(await readFile(filePath, "utf8"));
+  } catch (error) {
+    const missing = error instanceof Error && "code" in error && error.code === "ENOENT";
+    if (!missing) log(`\uBCF8 \uAE30\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC0C8\uB85C \uC801\uC2B5\uB2C8\uB2E4: ${errorText(error)}`);
+    return {};
+  }
+}
+async function writeSeen(filePath, seen) {
+  await mkdir(path4.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(seen, null, 2)}
+`);
+}
+function createReleaseWatcher(deps) {
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? ((message) => console.log(`[watch] ${message}`));
+  const seenPath = path4.join(deps.root ?? process.cwd(), seenFile);
+  const pending = /* @__PURE__ */ new Map();
+  let polling = false;
+  let draining = false;
+  async function listAll() {
+    return Promise.allSettled(watchTargets.map((target) => deps.listSignals(target)));
+  }
+  function observe(record, target, signals) {
+    const key = targetKey(target);
+    const known = record[key];
+    const newest = newestUnseen(signals, known ?? null);
+    if (!newest) {
+      if (known !== void 0) return false;
+      record[key] = emptySeen;
+      return true;
+    }
+    record[key] = newest.id;
+    if (known !== void 0) pending.set(key, { signal: newest, since: now() });
+    return true;
+  }
+  async function poll() {
+    const current = await readSeen(seenPath, log);
+    const results = await listAll();
+    let changed = false;
+    results.forEach((result, index) => {
+      const target = watchTargets[index];
+      if (result.status === "rejected") {
+        log(`${targetKey(target)} \uBAA9\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC774\uBC88 \uD68C\uCC28\uB97C \uAC74\uB108\uB701\uB2C8\uB2E4: ${errorText(result.reason)}`);
+        return;
+      }
+      changed = observe(current, target, result.value) || changed;
+    });
+    if (changed) await writeSeen(seenPath, current);
+  }
+  async function adhocReady(key, entry) {
+    if (!isIosProd(entry.signal.target)) return true;
+    try {
+      if (await deps.findAdhoc(entry.signal)) return true;
+    } catch (error) {
+      log(`${entry.signal.version} Ad-hoc \uD655\uC778 \uC2E4\uD328: ${errorText(error)}`);
+    }
+    if (now() - entry.since <= adhocWaitMs) return false;
+    pending.delete(key);
+    await deps.failIos(entry.signal, adhocMissingMessage(entry.signal.version)).catch((error) => {
+      log(`${entry.signal.version} install_failed \uAE30\uB85D \uC2E4\uD328: ${errorText(error)}`);
+    });
+    return false;
+  }
+  async function runNext() {
+    for (const [key, entry] of pending) {
+      if (deps.isBusy()) return false;
+      if (!await adhocReady(key, entry)) continue;
+      if (pending.get(key) !== entry) return true;
+      pending.delete(key);
+      await deps.startRun(entry.signal).catch((error) => {
+        log(`${key} ${entry.signal.version} \uC790\uB3D9 \uC810\uAC80 \uC2E4\uD328: ${errorText(error)}`);
+      });
+      return true;
+    }
+    return false;
+  }
+  async function drain() {
+    if (draining) return;
+    draining = true;
+    try {
+      while (await runNext()) ;
+    } finally {
+      draining = false;
+    }
+  }
+  async function tick() {
+    if (!polling) {
+      polling = true;
+      try {
+        await poll();
+      } catch (error) {
+        log(`\uAC10\uC2DC \uD68C\uCC28 \uC2E4\uD328: ${errorText(error)}`);
+      } finally {
+        polling = false;
+      }
+    }
+    await drain();
+  }
+  return { tick };
+}
+
+// packages/server/src/watch.ts
+function signalLister(fetchJson, install) {
+  const ascFetch = ascFetchJson();
+  return async (target) => {
+    if (target.platform === "ios") return testflightSignals(target, await listTestflightBuilds(ascFetch, ascAppId(target.kind)));
+    return releaseSignals(target, await listReleases(firebaseAppId(target.platform, target.kind, install), fetchJson));
+  };
+}
+function adhocFinder(fetchJson, install) {
+  return async (signal) => {
+    const releases = await listReleases(firebaseAppId("ios", "prod", install), fetchJson);
+    return pickRelease(releases, signal.version) !== null;
+  };
+}
+function startAutoWatch(deps) {
+  const fetchJson = deps.fetchJson ?? defaultBuildDeps(deps.install).fetchJson;
+  const watcher = createReleaseWatcher({
+    listSignals: signalLister(fetchJson, deps.install),
+    isBusy: deps.isBusy,
+    startRun: deps.runAuto,
+    findAdhoc: adhocFinder(fetchJson, deps.install),
+    failIos: deps.failIos,
+    log: deps.log
+  });
+  void watcher.tick();
+  const timer = setInterval(() => void watcher.tick(), releasePollMs);
+  timer.unref();
+  return { tick: () => watcher.tick(), stop: () => clearInterval(timer) };
+}
+
+// packages/server/src/farm.ts
+function createFarm(options) {
+  loadDotEnv();
+  const { app } = options;
+  const scenarios = farmScenarios(app);
+  const exec = options.exec ?? execFileText;
+  const log = options.log ?? ((message) => console.log(`[farm] ${message}`));
+  const locks = new DeviceLocks();
+  const hub = createStreamHub({ app });
+  const deviceDeps = createDeviceDeps(app, exec, hub);
+  const devices = createDeviceList(deviceDeps.listDevices, locks);
+  const control = createControlLog(locks);
+  const capture = createCapture(hub);
+  let latest = null;
+  let runAbort = null;
+  let exploring = null;
+  let watch = null;
+  let policyWatch = null;
+  const gate = createJobGate(() => {
+    try {
+      pruneRuns(devicesRoot, Date.now());
+    } catch (error) {
+      log(`\uBCF4\uAD00 \uC815\uB9AC \uC2E4\uD328: ${errorMessage(error)}`);
+    }
+    if (watch) void watch.tick();
+  });
+  const buttonCheck = () => {
+    let allowlist = null;
+    const loadAllowlist = () => allowlist ??= loadExploreInputs().allowlist;
+    return {
+      guard: (driver) => defaultGuard(driver, webOrigin(app, "dev"), loadAllowlist(), (request) => log(`\uBC84\uD2BC \uB20C\uB7EC\uBCF4\uAE30 \uC911 \uB9C9\uC740 \uC694\uCCAD: ${request.method} ${request.path}`)),
+      probe: (driver, ring, since) => probeScreen(driver, ring, since, loadAllowlist()),
+      recordMap: (from, buttons) => recordScreenMap(from, buttons)
+    };
+  };
+  const dataQa = () => {
+    const origin = apiOrigin(app);
+    if (!origin || app.qa.screens.length === 0) return {};
+    return { qaScreens: app.qa.screens, runQa: (driver, screen) => runScreenQa(driver, screen, { apiOrigin: origin }) };
+  };
+  const knownScreens = () => {
+    const edges = readScreenMap().edges;
+    return [.../* @__PURE__ */ new Set([...scenarios.map((scenario) => scenario.path), ...edges.map((edge) => edge.from), ...edges.flatMap((edge) => edge.to ? [edge.to] : [])])].sort();
+  };
+  const policyCheck = () => {
+    const screens = policyScreens(readAllPageRules(), knownScreens(), readFigmaCache(), readFrontFigmaMap()?.routes);
+    if (screens.length === 0) return {};
+    const ignores = readIgnores();
+    return { policyScreens: screens, runPolicy: (driver, screen) => checkPolicyScreen(driver, screen, { ask: askClaude, ignores }) };
+  };
+  const runDeps = () => ({
+    ...deviceDeps,
+    exec,
+    locks,
+    listDevices: devices.connected,
+    scenarios,
+    flows: readReady(),
+    buttonCheck: buttonCheck(),
+    ...dataQa(),
+    ...policyCheck(),
+    onUpdate: (run) => {
+      latest = run;
+      writeRun(run);
+    },
+    capture,
+    baselineFor: (device, scenario, screenshot) => baselineFor(device, scenario, screenshot),
+    log
+  });
+  const exploreDeps = () => ({
+    ...loadExploreInputs(),
+    app,
+    webOrigin: webOrigin(app, "dev"),
+    locks,
+    listDevices: devices.connected,
+    openDriver: deviceDeps.openDriver,
+    capture,
+    onUpdate: (results) => {
+      exploring = results;
+    },
+    log
+  });
+  function background(kind, started) {
+    started.catch((error) => log(`${kind} \uC2E4\uD328: ${errorMessage(error)}`));
+  }
+  const auto = createAutoRuns({
+    connected: devices.connected,
+    gate,
+    runDeps,
+    record: (run) => {
+      writeRun(run);
+      latest = run;
+    },
+    log
+  });
+  async function openIosSessions() {
+    const ios = (await devices.connected()).filter((device) => device.platform === "ios");
+    await Promise.all(ios.map((device) => getIosSession(device.id, appIdFor(app, "dev", "ios"), app.ios).catch((error) => log(`${device.id} Appium \uC138\uC158\uC744 \uBABB \uC5F4\uC5C8\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`))));
+  }
+  return {
+    app,
+    resultsRoot: testResultsRoot,
+    locks,
+    mjpegUrl: iosMjpegUrl,
+    ensureIosSession: async (id) => {
+      await getIosSession(id, appIdFor(app, "dev", "ios"), app.ios);
+    },
+    isBusy: gate.isBusy,
+    listDevices: devices.withState,
+    platformOf: async (id) => (await devices.withState()).find((device) => device.id === id)?.platform ?? null,
+    startRun: (request) => {
+      const runId = createRunId(Date.now());
+      const abort = new AbortController();
+      const started = gate.start("run", () => runDevices({ ...request, runId }, { ...runDeps(), signal: abort.signal }));
+      if (!started) return { ok: false, error: gate.busyMessage() };
+      runAbort = abort;
+      background(
+        "\uAE30\uAE30 \uC810\uAC80",
+        started.finally(() => {
+          if (runAbort === abort) runAbort = null;
+        })
+      );
+      return { ok: true, runId };
+    },
+    stopRun: () => {
+      if (!runAbort || runAbort.signal.aborted) return false;
+      runAbort.abort();
+      log("\uC810\uAC80 \uBA48\uCD94\uAE30 \uC694\uCCAD");
+      return true;
+    },
+    latestRun: () => latest,
+    pendingBaselines: () => pendingDeviceBaselines(),
+    candidatePng: (name) => candidatePng(name),
+    confirmBaselines: (names) => confirmDeviceBaselines(names),
+    startExplore: (request) => {
+      if (gate.isBusy()) return { ok: false, error: gate.busyMessage() };
+      const deps = exploreDeps();
+      const runId = createRunId(Date.now());
+      const started = gate.start("explore", () => runExplore({ deviceIds: request.deviceIds, runId }, deps).finally(() => {
+        exploring = null;
+      }));
+      if (!started) return { ok: false, error: gate.busyMessage() };
+      background("\uD0D0\uC0C9", started);
+      return { ok: true, runId };
+    },
+    latestExplore: () => exploring ?? readLatestExplore(),
+    replay: async ({ runId, deviceId, pathId }) => {
+      let issues = [];
+      const deps = exploreDeps();
+      const started = gate.start("replay", async () => {
+        issues = await replayOne(deviceId, runId, pathId, deps);
+      });
+      if (!started) throw new ExploreRequestError(409, gate.busyMessage());
+      await started;
+      return issues;
+    },
+    sendInput: (id, platform, event) => platform === "android" ? hub.sendAndroid(id, event) : hub.sendIos(id, event),
+    watchVideo: (id, sink) => watchVideo(hub, id, sink),
+    recordControl: control.record,
+    policyState: () => policyWatch?.state() ?? null,
+    checkPolicy: () => policyWatch?.checkNow() ?? false,
+    start: async () => {
+      if (closeUnfinishedRun(devicesRoot)) log("\uB05D\uB098\uC9C0 \uC54A\uC740 \uC2E4\uD589\uC744 \uC11C\uBC84 \uC7AC\uC2DC\uC791\uC73C\uB85C \uB2EB\uC558\uC2B5\uB2C8\uB2E4.");
+      log(`\uBCF4\uAD00 \uAE30\uAC04\uC774 \uC9C0\uB09C \uC2E4\uD589 ${pruneRuns(devicesRoot, Date.now())}\uAC1C\uB97C \uC9C0\uC6E0\uC2B5\uB2C8\uB2E4.`);
+      latest = readLatestRun(devicesRoot);
+      void openIosSessions().catch((error) => log(`iOS \uC138\uC158 \uC900\uBE44 \uC2E4\uD328: ${errorMessage(error)}`));
+      watch = startAutoWatch({ isBusy: gate.isBusy, runAuto: auto.runAuto, failIos: auto.failIos, log, install: app.install });
+      policyWatch = startPolicyWatch({ app, log, knownScreens });
+    },
+    stop: async () => {
+      watch?.stop();
+      policyWatch?.stop();
+      control.stop();
+      await closeAllIosSessions();
+    }
+  };
+}
+
+// packages/server/src/http/device-api.ts
+var prodExploreMessage = "\uC6B4\uC601 \uBE4C\uB4DC\uB294 \uD0D0\uC0C9\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+var noLockMessage = "\uC870\uC791 \uC7A0\uAE08\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 \uC870\uC791\uC744 \uC2DC\uC791\uD574 \uC8FC\uC138\uC694.";
+var botLockMessage = "\uBD07\uC774 \uC810\uAC80 \uC911\uC778 \uAE30\uAE30\uC785\uB2C8\uB2E4.";
+var baselineBusyMessage = "\uAE30\uAE30 \uC810\uAC80 \uC911\uC5D0\uB294 \uAE30\uC900\uC744 \uD655\uC815\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+var flowBusyMessage = "\uAE30\uAE30 \uC810\uAC80 \uC911\uC5D0\uB294 \uD50C\uB85C\uC6B0\uB97C \uD655\uC815\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+var apiPrefix = "/api/devices";
+var userHeader2 = "tailscale-user-login";
+var maxBodyBytes = 1024 * 1024;
+var mapFlowIdHashLength = 8;
+var buildKinds = ["dev", "prod"];
+var resultFileTypes = {
+  ".png": "image/png",
+  ".mp4": "video/mp4",
+  ".jsonl": "application/x-ndjson; charset=utf-8",
+  ".json": "application/json; charset=utf-8"
+};
+var closeReasonLength = 60;
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function sendJson(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.setHeader("cache-control", "no-store");
+  res.end(JSON.stringify(body));
+}
+function sendFile(res, type, data) {
+  res.statusCode = 200;
+  res.setHeader("content-type", type);
+  res.setHeader("cache-control", "no-store");
+  res.end(data);
+}
+async function readBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    size += buffer.length;
+    if (size > maxBodyBytes) throw new HttpError(413, "\uC694\uCCAD \uBCF8\uBB38\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4.");
+    chunks.push(buffer);
+  }
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new HttpError(400, "\uC694\uCCAD \uBCF8\uBB38\uC774 JSON\uC774 \uC544\uB2D9\uB2C8\uB2E4.");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new HttpError(400, "\uC694\uCCAD \uBCF8\uBB38\uC740 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+  return parsed;
+}
+function nonEmptyString(value, field2) {
+  if (typeof value !== "string" || !value.trim()) throw new HttpError(400, `${field2}\uB294 \uBE48 \uBB38\uC790\uC5F4\uC774 \uC544\uB2C8\uC5B4\uC57C \uD569\uB2C8\uB2E4.`);
+  return value.trim();
+}
+function parseDevices(value) {
+  if (value === "all") return "all";
+  if (Array.isArray(value) && value.length > 0 && value.every((id) => typeof id === "string" && id.trim())) return value.map((id) => id.trim());
+  throw new HttpError(400, 'devices\uB294 "all" \uB610\uB294 \uAE30\uAE30 id \uBC30\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.');
+}
+function parseKind(value) {
+  const kind = buildKinds.find((item) => item === value);
+  if (!kind) throw new HttpError(400, "kind\uB294 dev \uB610\uB294 prod\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+  return kind;
+}
+function parseNames(value) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value) && value.every((name) => typeof name === "string")) return value;
+  throw new HttpError(400, "names\uB294 \uBB38\uC790\uC5F4 \uBC30\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+}
+function createAccessMiddleware(domains) {
+  return (req, res, next) => accessGate(req, res, next, domains);
+}
+function accessGate(req, res, next, domains) {
+  const access = decideAccess({ remoteAddress: req.socket.remoteAddress, headers: req.headers }, domains);
+  if (access.ok) return next();
+  res.statusCode = access.status;
+  res.setHeader("cache-control", "no-store");
+  if ((req.url ?? "").startsWith("/api/")) {
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ error: access.message }));
+    return;
+  }
+  res.setHeader("content-type", "text/plain; charset=utf-8");
+  res.end(`\uB514\uBC14\uC774\uC2A4\uD31C: ${access.message}`);
+}
+function userOf(req) {
+  const header = req.headers[userHeader2];
+  const value = (Array.isArray(header) ? header[0] : header)?.trim();
+  return value || localUser;
+}
+function resolveResultFile(root, relative) {
+  if (!relative || path5.isAbsolute(relative) || relative.includes("\0")) return null;
+  const type = resultFileTypes[path5.extname(relative).toLowerCase()];
+  if (!type) return null;
+  try {
+    const base = realpathSync(root);
+    const inside = (target2) => target2.startsWith(base + path5.sep);
+    const target = path5.resolve(base, relative);
+    if (!inside(target)) return null;
+    const real = realpathSync(target);
+    return inside(real) && statSync(real).isFile() ? { file: real, type } : null;
+  } catch {
+    return null;
+  }
+}
+var noRunToStopMessage = "\uBA48\uCD9C \uC810\uAC80\uC774 \uC5C6\uC5B4\uC694.";
+async function stopRun({ farm, res }) {
+  if (!farm.stopRun()) return sendJson(res, 409, { error: noRunToStopMessage });
+  sendJson(res, 200, { stopping: true });
+}
+async function startRun({ farm, req, res }) {
+  const body = await readBody(req);
+  if (body.flowsOnly !== void 0 && typeof body.flowsOnly !== "boolean") throw new HttpError(400, "flowsOnly\uB294 true \uB610\uB294 false\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+  if (body.buttonCheck !== void 0 && typeof body.buttonCheck !== "boolean") throw new HttpError(400, "buttonCheck\uB294 true \uB610\uB294 false\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+  const flowsOnly = body.flowsOnly === true;
+  const version = flowsOnly ? installedVersionLabel : nonEmptyString(body.version, "version");
+  const request = { kind: parseKind(body.kind), version, deviceIds: parseDevices(body.devices), flowsOnly, buttonCheck: body.buttonCheck === true };
+  const started = farm.startRun(request);
+  if (!started.ok) return sendJson(res, 409, { error: started.error });
+  sendJson(res, 202, { runId: started.runId });
+}
+async function startExplore({ farm, req, res }) {
+  const body = await readBody(req);
+  if (body.build === "prod") return sendJson(res, 400, { error: prodExploreMessage });
+  if (body.build !== void 0 && body.build !== "dev") throw new HttpError(400, "build\uB294 dev\uB9CC \uBC1B\uC2B5\uB2C8\uB2E4.");
+  const started = farm.startExplore({ deviceIds: parseDevices(body.devices) });
+  if (!started.ok) return sendJson(res, 409, { error: started.error });
+  sendJson(res, 202, { runId: started.runId });
+}
+async function replay({ farm, req, res }) {
+  const body = await readBody(req);
+  const input2 = { runId: nonEmptyString(body.runId, "runId"), deviceId: nonEmptyString(body.deviceId, "deviceId"), pathId: nonEmptyString(body.pathId, "pathId") };
+  sendJson(res, 200, await farm.replay(input2));
+}
+async function confirmBaselines({ farm, req, res }) {
+  const names = parseNames((await readBody(req)).names);
+  if (farm.isBusy()) return sendJson(res, 409, { error: baselineBusyMessage });
+  sendJson(res, 200, { confirmed: farm.confirmBaselines(names) });
+}
+function flowsState() {
+  return { candidates: readCandidates(), ready: readReady(), prds: listPrds(), prdRootSet: prdRoot() !== null, llmConfigured: llmConfigured() };
+}
+async function generateFlows({ farm, req, res }) {
+  const result = await generateFromPrd(farm.app, nonEmptyString((await readBody(req)).prd, "prd"));
+  if (!result.ok) return sendJson(res, result.status, { error: result.error });
+  sendJson(res, 200, result);
+}
+async function confirmFlowCandidates({ farm, req, res }) {
+  const ids = parseNames((await readBody(req)).ids);
+  if (farm.isBusy()) return sendJson(res, 409, { error: flowBusyMessage });
+  sendJson(res, 200, { confirmed: confirmFlows(ids) });
+}
+async function mapFlowCandidate({ farm, res, req }) {
+  const body = await readBody(req);
+  const name = nonEmptyString(body.name, "name");
+  const steps = stepsOf(body.steps, farm.app.guard.forbiddenClickNames);
+  if (typeof steps === "string") throw new HttpError(400, steps);
+  const error = mapFlowError(readScreenMap().edges, steps, mapRulesOf(farm.app));
+  if (error) throw new HttpError(400, error);
+  const id = `map-${prdHash(JSON.stringify(steps)).slice(0, mapFlowIdHashLength)}`;
+  const proposal = readReady().some((flow2) => flow2.id === id) ? "update" : "create";
+  const requirement = `\uD654\uBA74 \uC9C0\uB3C4\uC5D0\uC11C \uBE14\uB85D ${steps.length}\uAC1C\uB97C \uC774\uC5B4 \uBD99\uC784`;
+  const flow = { id, name, source: "map_built", status: "generated", prd: mapFlowPrd, requirement, proposal, steps };
+  addCandidate(flow);
+  sendJson(res, 200, { id });
+}
+async function candidate({ farm, res, url }) {
+  const png = farm.candidatePng(url.searchParams.get("name") ?? "");
+  if (!png) return sendJson(res, 404, { error: "\uD6C4\uBCF4 \uD654\uBA74\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." });
+  sendFile(res, "image/png", png);
+}
+async function checkPolicy({ farm, res }) {
+  const state = farm.policyState();
+  if (!state?.configured) return sendJson(res, 409, { error: "CONFLUENCE_EMAIL\xB7CONFLUENCE_API_TOKEN\uC774 \uC5C6\uC5B4 \uC815\uCC45\uC744 \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." });
+  if (!farm.checkPolicy()) return sendJson(res, 409, { error: "\uC774\uBBF8 \uC815\uCC45\uC744 \uD655\uC778\uD558\uB294 \uC911\uC785\uB2C8\uB2E4." });
+  sendJson(res, 202, { started: true });
+}
+async function ignorePolicy({ req, res }) {
+  const body = await readBody(req);
+  const key = nonEmptyString(body.key, "key");
+  const hash = typeof body.hash === "string" ? body.hash : "";
+  addIgnore({ key, hash, reason: nonEmptyString(body.reason, "reason"), at: (/* @__PURE__ */ new Date()).toISOString() });
+  sendJson(res, 200, { items: readIgnores() });
+}
+async function unignorePolicy({ req, res }) {
+  const body = await readBody(req);
+  removeIgnore(nonEmptyString(body.key, "key"), typeof body.hash === "string" ? body.hash : "");
+  sendJson(res, 200, { items: readIgnores() });
+}
+async function chaosRun({ res, url }) {
+  const run = readChaosRun(url.searchParams.get("id") ?? "");
+  if (!run) return sendJson(res, 404, { error: "\uCE74\uC624\uC2A4 \uC2E4\uD589\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." });
+  sendJson(res, 200, run);
+}
+async function resultFile({ farm, res, url }) {
+  const found = resolveResultFile(farm.resultsRoot, url.searchParams.get("path") ?? "");
+  if (!found) return sendJson(res, 404, { error: "\uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." });
+  sendFile(res, found.type, readFileSync4(found.file));
+}
+function ownsLock(farm, id, user) {
+  const owner = farm.locks.ownerOf(id);
+  return owner?.kind === "user" && owner.user === user;
+}
+async function input({ farm, req, res, id }) {
+  if (!ownsLock(farm, id, userOf(req))) return sendJson(res, 423, { error: noLockMessage });
+  const event = parseInputEvent(await readBody(req));
+  if (!event) throw new HttpError(400, "\uC785\uB825 \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  const platform = await farm.platformOf(id);
+  if (!platform) throw new HttpError(404, "\uC5F0\uACB0\uB41C \uAE30\uAE30\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+  if (platform === "ios" && event.type === "key" && event.key === "back") throw new HttpError(400, iosBackUnsupported);
+  farm.locks.touch(id);
+  await farm.sendInput(id, platform, event);
+  sendJson(res, 200, { ok: true });
+}
+async function lock({ farm, req, res, id }) {
+  const user = userOf(req);
+  const already = ownsLock(farm, id, user);
+  if (!farm.locks.acquire(id, { kind: "user", user })) {
+    const owner = farm.locks.ownerOf(id);
+    return sendJson(res, 409, { error: owner?.kind === "user" ? `${owner.user}\uB2D8\uC774 \uC870\uC791 \uC911\uC785\uB2C8\uB2E4.` : botLockMessage });
+  }
+  if (!already) farm.recordControl({ user, deviceId: id, action: "lock" });
+  sendJson(res, 200, { ok: true });
+}
+async function unlock({ farm, req, res, id }) {
+  const user = userOf(req);
+  if (ownsLock(farm, id, user)) {
+    farm.locks.release(id, { kind: "user", user });
+    farm.recordControl({ user, deviceId: id, action: "release" });
+  }
+  sendJson(res, 200, { ok: true });
+}
+async function touch({ farm, req, res, id }) {
+  const locked = ownsLock(farm, id, userOf(req));
+  if (locked) farm.locks.touch(id);
+  sendJson(res, 200, { ok: true, locked });
+}
+async function mjpeg({ farm, req, res, id }) {
+  if (await farm.platformOf(id) !== "ios") throw new HttpError(404, "\uC5F0\uACB0\uB41C iOS \uAE30\uAE30\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+  await farm.ensureIosSession?.(id);
+  const upstream = httpGet(farm.mjpegUrl, (source) => {
+    res.statusCode = source.statusCode ?? 502;
+    res.setHeader("content-type", source.headers["content-type"] ?? "multipart/x-mixed-replace");
+    res.setHeader("cache-control", "no-store");
+    source.pipe(res);
+  });
+  upstream.on("error", (error) => {
+    if (!res.headersSent) sendJson(res, 502, { error: `iOS \uD654\uBA74\uC744 \uBABB \uBC1B\uC558\uC2B5\uB2C8\uB2E4: ${error.message}` });
+    else res.destroy();
+  });
+  req.on("close", () => upstream.destroy());
+}
+async function streamOverHttp({ res }) {
+  sendJson(res, 426, { error: "WebSocket\uC73C\uB85C \uC5F0\uACB0\uD574 \uC8FC\uC138\uC694." });
+}
+var json = (load) => async ({ farm, res }) => sendJson(res, 200, await load(farm));
+var fixedRoutes = {
+  "GET /": json((farm) => farm.listDevices()),
+  "GET /app": json((farm) => publicAppConfig(farm.app)),
+  "POST /run": startRun,
+  "POST /run/stop": stopRun,
+  "GET /runs/latest": json((farm) => farm.latestRun()),
+  "GET /baselines/pending": json((farm) => farm.pendingBaselines()),
+  "GET /baselines/candidate": candidate,
+  "POST /baselines/confirm": confirmBaselines,
+  "POST /explore": startExplore,
+  "GET /explore/latest": json((farm) => farm.latestExplore()),
+  "POST /explore/replay": replay,
+  "GET /files": resultFile,
+  "GET /flows": json(() => flowsState()),
+  "POST /flows/generate": generateFlows,
+  "POST /flows/confirm": confirmFlowCandidates,
+  "POST /flows/from-map": mapFlowCandidate,
+  "GET /screen-map": json(() => readScreenMap()),
+  "GET /chaos": json(() => listChaosRuns()),
+  "GET /policy": json((farm) => farm.policyState()),
+  "POST /policy/check": checkPolicy,
+  "GET /policy/ignored": json(() => ({ items: readIgnores() })),
+  "POST /policy/ignore": ignorePolicy,
+  "POST /policy/unignore": unignorePolicy,
+  "GET /chaos/run": chaosRun
+};
+var deviceRoutes = {
+  "POST input": input,
+  "POST lock": lock,
+  "DELETE lock": unlock,
+  "POST lock/touch": touch,
+  "GET mjpeg": mjpeg,
+  "GET stream": streamOverHttp
+};
+var devicePathPattern = /^\/([^/]+)\/(input|lock|lock\/touch|mjpeg|stream)$/;
+function findRoute(method, rest) {
+  const fixed = fixedRoutes[`${method} ${rest || "/"}`];
+  if (fixed) return { handler: fixed, id: "" };
+  const match = devicePathPattern.exec(rest);
+  const handler = match ? deviceRoutes[`${method} ${match[2]}`] : void 0;
+  return match && handler ? { handler, id: decodeURIComponent(match[1]) } : null;
+}
+function statusOf(error) {
+  if (error instanceof HttpError || error instanceof ExploreRequestError) return error.status;
+  return 500;
+}
+function deviceMiddleware(farm) {
+  return (req, res, next) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== apiPrefix && !url.pathname.startsWith(`${apiPrefix}/`)) return next();
+    const route = findRoute(req.method ?? "GET", url.pathname.slice(apiPrefix.length).replace(/\/$/, ""));
+    if (!route) return sendJson(res, 404, { error: "\uC5C6\uB294 API\uC785\uB2C8\uB2E4." });
+    route.handler({ farm, req, res, url, id: route.id }).catch((error) => {
+      if (!res.headersSent) sendJson(res, statusOf(error), { error: errorMessage(error) });
+    });
+  };
+}
+var streamPathPattern = /^\/api\/devices\/([^/]+)\/stream$/;
+function streamIdOf(rawUrl) {
+  const match = streamPathPattern.exec(new URL(rawUrl ?? "/", "http://127.0.0.1").pathname);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+async function attachStream(farm, id, socket) {
+  let unsubscribe = null;
+  socket.on("close", () => unsubscribe?.());
+  try {
+    if (await farm.platformOf(id) !== "android") throw new Error("Android \uAE30\uAE30\uB9CC \uC2A4\uD2B8\uB9BC\uC744 \uBCF4\uB0C5\uB2C8\uB2E4. iOS\uB294 mjpeg\uB97C \uC4F0\uC138\uC694.");
+    const stop = await farm.watchVideo(id, {
+      header: (header) => socket.send(JSON.stringify(header)),
+      packet: (packet) => {
+        if (socket.readyState === WebSocket.OPEN) socket.send(packet);
+      }
+    });
+    if (socket.readyState === WebSocket.OPEN) unsubscribe = stop;
+    else stop();
+  } catch (error) {
+    socket.close(1011, errorMessage(error).slice(0, closeReasonLength));
+  }
+}
+function devicePlugin(options) {
+  const { app, farm } = options;
+  return {
+    name: "device-farm-devices",
+    configureServer: attach,
+    // `npx device-farm dev`는 미리 빌드한 화면을 vite preview로 연다. API·스트림은 dev와 똑같이 붙인다.
+    configurePreviewServer: attach
+  };
+  function attach(server) {
+    const running = farm ? null : createFarm({ app });
+    const active = farm ?? running;
+    if (!active) return;
+    void running?.start().catch((error) => console.error(`[farm] \uC2DC\uC791 \uC2E4\uD328: ${errorMessage(error)}`));
+    const domains = allowedDomains(void 0, app.access.allowedDomains);
+    server.middlewares.use(createAccessMiddleware(domains));
+    server.middlewares.use(deviceMiddleware(active));
+    const sockets = new WebSocketServer({ noServer: true });
+    server.httpServer?.on("upgrade", (req, socket, head) => {
+      const id = streamIdOf(req.url);
+      if (id === null) return;
+      const access = decideAccess({ remoteAddress: req.socket.remoteAddress, headers: req.headers }, domains);
+      if (!access.ok) {
+        socket.end(`HTTP/1.1 ${access.status} ${access.status === 401 ? "Unauthorized" : "Forbidden"}\r
+Connection: close\r
+\r
+`);
+        return;
+      }
+      sockets.handleUpgrade(req, socket, head, (ws) => void attachStream(active, id, ws));
+    });
+    server.httpServer?.on("close", () => {
+      sockets.close();
+      void running?.stop();
+    });
+  }
+}
+
+// apps/cli/src/serve.ts
+var webDist = fileURLToPath(new URL("./web", import.meta.url));
+async function serve(port) {
+  if (!existsSync3(path6.join(webDist, "index.html"))) throw new Error(`\uD654\uBA74 \uBE4C\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4: ${webDist} (\uC800\uC7A5\uC18C\uC5D0\uC11C\uB294 npm run build \uB610\uB294 npm run dev)`);
+  const app = await cliApp();
+  const server = await preview({
+    configFile: false,
+    // root를 web 바로 위(dist)로 둬야 vite가 outDir=root 경고를 내지 않는다
+    root: path6.dirname(webDist),
+    build: { outDir: webDist },
+    preview: { host: "127.0.0.1", port, strictPort: true, allowedHosts: [".ts.net"] },
+    plugins: [devicePlugin({ app })]
+  });
+  server.printUrls();
+  const close = () => {
+    server.close().finally(() => process.exit(0));
+  };
+  process.once("SIGINT", close);
+  process.once("SIGTERM", close);
+}
+export {
+  serve
+};