@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/chunk-WTTCWFOX.js

@@ -0,0 +1,161 @@
+import {
+  policyRoot,
+  readJudgeCache,
+  readScreenHashes,
+  writeJudgeCache,
+  writeScreenHashes
+} from "./chunk-VGPCTMUA.js";
+import {
+  compareCopyRules,
+  diffFigmaCopy,
+  docsMismatchChecks,
+  figmaChecks,
+  isIgnored,
+  rulesForScreen,
+  screenTextHash,
+  situationalRules
+} from "./chunk-UAHWEUDI.js";
+import {
+  classifyWithFigma,
+  findingLabels,
+  parseJsonObject,
+  screenMatches,
+  shortHash
+} from "./chunk-F6PZOBU6.js";
+import {
+  samePath,
+  sleep
+} from "./chunk-NLX3V7ZJ.js";
+
+// packages/engine/src/policy/screen-check.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+
+// packages/core/src/policy/judge.ts
+var judgeKey = (path2, screenHash, rules, figmaHash) => `${path2}|${screenHash}|${shortHash(rules.map((rule) => `${rule.id}:${rule.pageHash}`).sort().join(","))}|${figmaHash}`;
+var isSensitivePath = (path2) => /(account|bank|certif|identity|verify|auth|kyc|password|pin)/i.test(path2);
+var maxScreenChars = 6e3;
+var maxFigmaChars = 6e3;
+function judgePrompt(path2, text, rules, screenshotFile, figmaTexts = [], appName = "\uB300\uC0C1") {
+  return [
+    `${appName} \uC571 \uD654\uBA74 ${path2}\uC774 \uC544\uB798 \uC815\uCC45 \uADDC\uCE59\uC5D0 \uB9DE\uB294\uC9C0 \uD310\uC815\uD574 JSON \uD558\uB098\uB85C\uB9CC \uB2F5\uD558\uC138\uC694.`,
+    screenshotFile ? `\uD654\uBA74 \uC2A4\uD06C\uB9B0\uC0F7: ${screenshotFile} (Read \uB3C4\uAD6C\uB85C \uC5F4\uC5B4 \uBCF4\uC138\uC694)` : "\uC2A4\uD06C\uB9B0\uC0F7\uC740 \uC5C6\uC2B5\uB2C8\uB2E4(\uAC1C\uC778\uC815\uBCF4 \uD654\uBA74). \uD654\uBA74 \uAE00\uC790\uB85C\uB9CC \uD310\uC815\uD558\uC138\uC694.",
+    "",
+    "\uD310\uC815 \uAE30\uC900:",
+    '- "match": \uD654\uBA74\uC774 \uADDC\uCE59\uB300\uB85C\uB2E4.',
+    '- "differ": \uD654\uBA74\uC774 \uADDC\uCE59\uACFC \uB2E4\uB974\uB2E4. reason\uC5D0 \uD654\uBA74\uC5D0\uC11C \uBCF8 \uAC83\uC744 \uC801\uB294\uB2E4.',
+    '- "unknown": \uC9C0\uAE08 \uD654\uBA74 \uC0C1\uD0DC\uB85C\uB294 \uC54C \uC218 \uC5C6\uB2E4(\uADF8 \uC0C1\uD0DC\uAC00 \uC544\uB2D8, \uB370\uC774\uD130 \uC5C6\uC74C \uB4F1). \uC560\uB9E4\uD558\uBA74 unknown.',
+    "",
+    "differ\uC774\uBA74 \uC544\uB798 \uD53C\uADF8\uB9C8 \uB514\uC790\uC778 \uBB38\uAD6C\uB97C \uBCF4\uACE0 figma\uC5D0 \uD53C\uADF8\uB9C8\uAC00 \uC5B4\uB290 \uCABD\uACFC \uAC19\uC740\uC9C0 \uC801\uB294\uB2E4:",
+    '- "policy": \uD53C\uADF8\uB9C8\uAC00 \uC815\uCC45\uB300\uB85C\uB2E4(\uC571\uB9CC \uB2E4\uB974\uB2E4). "app": \uD53C\uADF8\uB9C8\uAC00 \uC571 \uD654\uBA74\uACFC \uAC19\uB2E4(\uC815\uCC45\uB9CC \uB2E4\uB974\uB2E4). "neither": \uC14B \uB2E4 \uB2E4\uB974\uB2E4. "unknown": \uD53C\uADF8\uB9C8\uB85C \uC54C \uC218 \uC5C6\uB2E4.',
+    "",
+    'reason\uC740 \uD55C\uAD6D\uC5B4 \uD55C \uC904\uB85C \uC4F4\uB2E4. \uD615\uC2DD: {"verdicts": [{"ruleId": "...", "result": "differ", "reason": "\uD55C \uC904", "figma": "app"}]}',
+    "",
+    "\uADDC\uCE59:",
+    ...rules.map((rule) => `- ${rule.id}: ${rule.statement} (\uADFC\uAC70: ${rule.evidence})`),
+    "",
+    "\uD654\uBA74 \uAE00\uC790:",
+    text.slice(0, maxScreenChars),
+    "",
+    "\uD53C\uADF8\uB9C8 \uB514\uC790\uC778 \uBB38\uAD6C(\uC774 \uD654\uBA74\uC5D0 \uC5F0\uACB0\uB41C \uB178\uB4DC\uB4E4, \uC5EC\uB7EC \uC0C1\uD0DC\uAC00 \uC11E\uC5EC \uC788\uB2E4):",
+    figmaTexts.length > 0 ? figmaTexts.join("\n").slice(0, maxFigmaChars) : "(\uC5C6\uC74C)"
+  ].join("\n");
+}
+var results = ["match", "differ", "unknown"];
+var sides = ["policy", "app", "neither", "unknown"];
+function parseVerdicts(text, rules) {
+  const parsed = parseJsonObject(text);
+  const ids = new Set(rules.map((rule) => rule.id));
+  const list = Array.isArray(parsed.verdicts) ? parsed.verdicts : [];
+  return list.flatMap((item) => {
+    const value = item;
+    if (typeof value.ruleId !== "string" || !ids.has(value.ruleId) || !results.includes(value.result)) return [];
+    const figma = sides.includes(value.figma) ? value.figma : "unknown";
+    return [{ ruleId: value.ruleId, result: value.result, reason: typeof value.reason === "string" ? value.reason : "", figma }];
+  });
+}
+function verdictChecks(rules, verdicts, context) {
+  const byId = new Map(verdicts.map((verdict) => [verdict.ruleId, verdict]));
+  return rules.map((rule) => {
+    const verdict = byId.get(rule.id);
+    const base = { id: rule.id, title: rule.statement, ignoreKey: rule.id, ignoreHash: rule.pageHash, pageId: rule.pageId };
+    if (!verdict || verdict.result === "unknown") return { ...base, ok: true, message: `\uD310\uB2E8 \uBD88\uAC00${verdict?.reason ? `: ${verdict.reason}` : ""}` };
+    if (verdict.result === "match") return { ...base, ok: true };
+    const figmaAgrees = verdict.figma === "policy" ? true : verdict.figma === "app" ? false : null;
+    const finding = classifyWithFigma(rule, figmaAgrees, context.screenChanged, context.now);
+    return { ...base, ok: false, finding, ignored: isIgnored(context.ignores, rule.id, rule.pageHash), message: `[${findingLabels[finding]}] ${verdict.reason} \xB7 \u300C${rule.pageTitle}\u300D` };
+  });
+}
+
+// packages/engine/src/policy/screen-check.ts
+var policySettleMs = 4e3;
+var policyOpenAttempts = 2;
+function policyScreens(pages, knownPaths, figmaCache, frontRoutes = {}) {
+  const concrete = (pattern) => pattern.includes("*") ? knownPaths.filter((known) => screenMatches(pattern, known)) : [pattern];
+  const paths = new Set(pages.flatMap((page) => [...page.screens, ...page.rules.flatMap((rule) => rule.screens)].flatMap(concrete)));
+  const allRules = pages.flatMap((page) => page.rules);
+  return [...paths].sort().map((screen) => {
+    const refs = /* @__PURE__ */ new Set([
+      ...pages.filter((page) => page.screens.some((pattern) => screenMatches(pattern, screen))).flatMap((page) => page.figma),
+      ...Object.entries(frontRoutes).flatMap(([route, routeRefs]) => screenMatches(route, screen) ? routeRefs : [])
+    ]);
+    const figmaTexts = [...refs].sort().flatMap((ref) => figmaCache[ref] ? [figmaCache[ref]] : []);
+    const texts = figmaTexts.flatMap((item) => item.texts);
+    return { path: screen, rules: rulesForScreen(allRules, screen), figma: texts.length > 0 ? { hash: shortHash(figmaTexts.map((item) => item.hash).join(",")), texts } : null };
+  });
+}
+async function judge(screen, text, screenHash, screenChanged, driver, deps) {
+  const root = deps.root ?? policyRoot;
+  const behaviors = screen.rules.filter((rule) => rule.kind === "behavior");
+  const context = { ignores: deps.ignores, screenChanged, now: deps.now?.() ?? Date.now() };
+  if (behaviors.length === 0) return { checks: [], cached: false };
+  const key = judgeKey(screen.path, screenHash, behaviors, screen.figma?.hash ?? "");
+  const cache = readJudgeCache(root);
+  if (cache[key]) return { checks: verdictChecks(behaviors, cache[key], context), cached: true };
+  if (!deps.ask) return { checks: [], cached: false, judgeError: "Claude\uB97C \uC4F8 \uC218 \uC5C6\uC5B4 \uD654\uBA74 \uB3D9\uC791 \uADDC\uCE59\uC744 \uD310\uC815\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4." };
+  let screenshotFile = null;
+  if (!isSensitivePath(screen.path)) {
+    screenshotFile = path.join(root, "judge-shots", `${shortHash(key)}.png`);
+    mkdirSync(path.dirname(screenshotFile), { recursive: true });
+    writeFileSync(screenshotFile, await driver.screenshot());
+  }
+  const prompt = judgePrompt(screen.path, text, behaviors, screenshotFile, screen.figma?.texts ?? [], driver.app.name);
+  const verdicts = parseVerdicts(await deps.ask(prompt, { allowRead: Boolean(screenshotFile) }), behaviors);
+  writeJudgeCache({ ...readJudgeCache(root), [key]: verdicts }, root);
+  return { checks: verdictChecks(behaviors, verdicts, context), cached: false };
+}
+async function checkPolicyScreen(driver, screen, deps) {
+  const root = deps.root ?? policyRoot;
+  let opened = "";
+  for (let attempt = 0; attempt < policyOpenAttempts && !samePath(screen.path, opened); attempt += 1) {
+    await driver.navigate(screen.path);
+    await sleep(deps.settleMs ?? policySettleMs);
+    opened = await driver.currentPath();
+  }
+  if (!samePath(screen.path, opened)) {
+    return { path: screen.path, situational: 0, cached: false, checks: [{ id: "open", title: "\uD654\uBA74 \uC5F4\uAE30", ok: false, message: `${screen.path} \uB300\uC2E0 ${opened} \uD654\uBA74\uC774 \uC5F4\uB824 \uC788\uC2B5\uB2C8\uB2E4.`, ignoreKey: "open", ignoreHash: "" }] };
+  }
+  const text = await driver.evaluate("document.body.innerText");
+  const screenHash = screenTextHash(text);
+  const hashes = readScreenHashes(root);
+  const screenChanged = hashes[screen.path] !== void 0 && hashes[screen.path] !== screenHash;
+  writeScreenHashes({ ...hashes, [screen.path]: screenHash }, root);
+  const now = deps.now?.() ?? Date.now();
+  const checks = compareCopyRules(screen.rules, { path: screen.path, text, ignores: deps.ignores, screenChanged, now, figmaTexts: screen.figma?.texts ?? null });
+  if (screen.figma) {
+    checks.push(...figmaChecks(diffFigmaCopy(screen.figma.texts, text), screen.figma.hash, screen.path, deps.ignores));
+    checks.push(...docsMismatchChecks(screen.rules, screen.figma.texts, text, deps.ignores));
+  }
+  const situational = situationalRules(screen.rules, screen.path).length;
+  try {
+    const judged = await judge(screen, text, screenHash, screenChanged, driver, deps);
+    return { path: screen.path, checks: [...checks, ...judged.checks], situational, cached: judged.cached, judgeError: judged.judgeError };
+  } catch (error) {
+    return { path: screen.path, checks, situational, cached: false, judgeError: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export {
+  policyScreens,
+  checkPolicyScreen
+};

package/dist/chunk-ZE2GGXFO.js

@@ -0,0 +1,169 @@
+import {
+  formatNetworkLog
+} from "./chunk-AVECSGEH.js";
+import {
+  getIosSession
+} from "./chunk-S6GHOP4B.js";
+import {
+  execFileText
+} from "./chunk-AXQNUPGC.js";
+
+// packages/devices/src/logs/collect.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var safariPollMs = 2e3;
+var httpErrorStatus = 400;
+var androidCrashMarker = "FATAL EXCEPTION";
+var iosCrashMarker = "Terminating app due to uncaught exception";
+function safeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.origin}${parsed.pathname}`;
+  } catch {
+    return url.split(/[?#]/)[0];
+  }
+}
+function logcatLineToEntry(line) {
+  const text = line.trim();
+  if (!text) return null;
+  return { source: text.includes(androidCrashMarker) ? "crash" : "system", text };
+}
+function syslogLineToEntry(line) {
+  const text = line.trim();
+  if (!text) return null;
+  return { source: text.includes(iosCrashMarker) ? "crash" : "system", text };
+}
+function consoleToEntry(type, text) {
+  return type === "error" ? { source: "console", text } : null;
+}
+function responseToEntry(status, method, url) {
+  if (status < httpErrorStatus) return null;
+  return { source: "network", text: formatNetworkLog(method || "UNKNOWN", status, safeUrl(url)) };
+}
+function requestFailedToEntry(method, url, errorText) {
+  return { source: "network", text: formatNetworkLog(method, 0, safeUrl(url), errorText) };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMessage(entry) {
+  if (!isRecord(entry) || typeof entry.message !== "string") return null;
+  try {
+    const parsed = JSON.parse(entry.message);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var severeLevels = ["error", "SEVERE"];
+function safariConsoleToEntry(entry) {
+  const message = parseMessage(entry);
+  if (!message || typeof message.text !== "string") return null;
+  const outerLevel = isRecord(entry) ? entry.level : void 0;
+  const isError = severeLevels.some((level) => level === message.level || level === outerLevel);
+  return isError ? { source: "console", text: message.text } : null;
+}
+function responseOf(params) {
+  const response = params.response;
+  if (!isRecord(response) || typeof response.status !== "number" || typeof response.url !== "string") return null;
+  return responseToEntry(response.status, "", response.url);
+}
+function safariNetworkToEntry(entry) {
+  const message = parseMessage(entry);
+  if (!message || !isRecord(message.params)) return null;
+  if (message.method === "Network.responseReceived") return responseOf(message.params);
+  if (message.method === "Network.loadingFailed") {
+    const errorText = typeof message.params.errorText === "string" ? message.params.errorText : "";
+    return { source: "network", text: formatNetworkLog("UNKNOWN", 0, "-", errorText) };
+  }
+  return null;
+}
+var defaultSpawn = (command, args) => spawn(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+function pipeLines(child, ring, toEntry, label) {
+  const lines = createInterface({ input: child.stdout });
+  lines.on("line", (line) => {
+    const entry = toEntry(line);
+    if (entry) ring.push(entry);
+  });
+  child.on("error", (error) => ring.push({ source: "system", text: `${label} \uC2E4\uD589 \uC2E4\uD328: ${error.message}` }));
+  return async () => {
+    lines.close();
+    child.kill("SIGTERM");
+  };
+}
+function isAndroidDriver(driver) {
+  return "context" in driver;
+}
+function watchPage(driver, ring) {
+  const page = driver.context;
+  const push = (entry) => entry && ring.push(entry);
+  const onConsole = (message) => push(consoleToEntry(message.type(), message.text()));
+  const onResponse = (response) => push(responseToEntry(response.status(), response.request().method(), response.url()));
+  const onFailed = (request) => push(requestFailedToEntry(request.method(), request.url(), request.failure()?.errorText ?? ""));
+  page.on("console", onConsole);
+  page.on("response", onResponse);
+  page.on("requestfailed", onFailed);
+  return async () => {
+    page.off("console", onConsole);
+    page.off("response", onResponse);
+    page.off("requestfailed", onFailed);
+  };
+}
+async function appPid(serial, appId, exec) {
+  const pid = (await exec("adb", ["-s", serial, "shell", "pidof", appId])).trim().split(/\s+/)[0];
+  if (!pid) throw new Error(`${appId} \uC571\uC774 \uC2E4\uD589 \uC911\uC774 \uC544\uB2D9\uB2C8\uB2E4.`);
+  return pid;
+}
+async function startAndroid(device, appId, driver, ring, deps) {
+  const pid = await appPid(device.id, appId, deps.exec ?? execFileText);
+  const spawnProcess = deps.spawnProcess ?? defaultSpawn;
+  const stops = [pipeLines(spawnProcess("adb", ["-s", device.id, "logcat", `--pid=${pid}`]), ring, logcatLineToEntry, "logcat")];
+  if (isAndroidDriver(driver)) stops.push(watchPage(driver, ring));
+  return stops;
+}
+function pollSafariLogs(session, ring, pollMs) {
+  let lastError = "";
+  let polling = false;
+  const pull = async (type, toEntry) => {
+    const entries = await session.getLogs(type);
+    for (const entry of entries) {
+      const line = toEntry(entry);
+      if (line) ring.push(line);
+    }
+  };
+  const poll = async () => {
+    if (polling) return;
+    polling = true;
+    try {
+      await pull("safariConsole", safariConsoleToEntry);
+      await pull("safariNetwork", safariNetworkToEntry);
+      lastError = "";
+    } catch (error) {
+      const text = `safari \uB85C\uADF8 \uC218\uC9D1 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`;
+      if (text !== lastError) ring.push({ source: "system", text });
+      lastError = text;
+    } finally {
+      polling = false;
+    }
+  };
+  const timer = setInterval(() => void poll(), pollMs);
+  return async () => clearInterval(timer);
+}
+async function startIos(device, appId, ring, deps) {
+  const session = deps.iosSession ?? await getIosSession(device.id, appId);
+  const spawnProcess = deps.spawnProcess ?? defaultSpawn;
+  return [
+    pipeLines(spawnProcess("idevicesyslog", ["-u", device.id, "-p", "Runner"]), ring, syslogLineToEntry, "idevicesyslog"),
+    pollSafariLogs(session, ring, deps.pollMs ?? safariPollMs)
+  ];
+}
+async function startCollectors(device, appId, driver, ring, deps = {}) {
+  const stops = device.platform === "android" ? await startAndroid(device, appId, driver, ring, deps) : await startIos(device, appId, ring, deps);
+  return async () => {
+    await Promise.all(stops.map((stop) => stop()));
+  };
+}
+
+export {
+  startCollectors
+};

package/dist/device-explore-PHS6SVEJ.js

@@ -0,0 +1,64 @@
+import {
+  CliError,
+  exitCodes,
+  exploreExitCode,
+  formatExploreRun,
+  formatExploreSummary,
+  isExploreFinished,
+  isRecord,
+  requestJson,
+  summarizeExplore
+} from "./chunk-P2M55S53.js";
+import {
+  parseExploreArgs
+} from "./chunk-4UOXXMXL.js";
+
+// apps/cli/src/device-explore.ts
+import { setTimeout as wait } from "timers/promises";
+var pollIntervalMs = 2e3;
+async function startExplore(port, body) {
+  const result = await requestJson(port, "/api/devices/explore", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!isRecord(result) || typeof result.runId !== "string") throw new CliError("\uB514\uBC14\uC774\uC2A4\uD31C \uC11C\uBC84\uAC00 runId\uB97C \uC8FC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  return result.runId;
+}
+async function readRuns(port, runId) {
+  const result = await requestJson(port, "/api/devices/explore/latest");
+  if (!Array.isArray(result)) return [];
+  return result.filter((run) => isRecord(run) && run.runId === runId);
+}
+async function followExplore(port, runId) {
+  const printed = /* @__PURE__ */ new Map();
+  for (; ; ) {
+    const runs = await readRuns(port, runId);
+    for (const run of runs) {
+      const line = formatExploreRun(run);
+      if (printed.get(run.deviceId) === line) continue;
+      printed.set(run.deviceId, line);
+      console.log(line);
+    }
+    if (isExploreFinished(runs)) return runs;
+    await wait(pollIntervalMs);
+  }
+}
+async function main() {
+  const args = parseExploreArgs(process.argv.slice(2));
+  if (!args.ok) throw new CliError(args.error);
+  const { devices, port, build } = args.value;
+  const runId = await startExplore(port, build ? { devices, build } : { devices });
+  console.log(`\uD0D0\uC0C9 \uC2DC\uC791 (${runId})`);
+  const runs = await followExplore(port, runId);
+  console.log(formatExploreSummary(summarizeExplore(runs)));
+  const code = exploreExitCode(runs);
+  console.log(`exit ${code}`);
+  return code;
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = exitCodes.failed;
+});

package/dist/device-run-XPNRYXEL.js

@@ -0,0 +1,60 @@
+import {
+  CliError,
+  changedLines,
+  exitCodes,
+  isRecord,
+  isRunFinished,
+  noDevicesMessage,
+  requestJson,
+  runExitCode
+} from "./chunk-P2M55S53.js";
+import {
+  parseRunArgs
+} from "./chunk-4UOXXMXL.js";
+
+// apps/cli/src/device-run.ts
+import { setTimeout as wait } from "timers/promises";
+var pollIntervalMs = 2e3;
+async function startRun(port, body) {
+  const result = await requestJson(port, "/api/devices/run", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!isRecord(result) || typeof result.runId !== "string") throw new CliError("\uB514\uBC14\uC774\uC2A4\uD31C \uC11C\uBC84\uAC00 runId\uB97C \uC8FC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  return result.runId;
+}
+async function readLatestRun(port) {
+  const result = await requestJson(port, "/api/devices/runs/latest");
+  if (!isRecord(result) || typeof result.runId !== "string") return null;
+  return result;
+}
+async function followRun(port, runId) {
+  const printed = /* @__PURE__ */ new Map();
+  for (; ; ) {
+    const run = await readLatestRun(port);
+    if (run?.runId === runId) {
+      for (const line of changedLines(run, printed)) console.log(line);
+      if (isRunFinished(run)) return run;
+    }
+    await wait(pollIntervalMs);
+  }
+}
+async function main() {
+  const args = parseRunArgs(process.argv.slice(2));
+  if (!args.ok) throw new CliError(args.error);
+  const { kind, version, devices, port } = args.value;
+  const runId = await startRun(port, { kind, version, devices });
+  console.log(`\uAE30\uAE30 \uC810\uAC80 \uC2DC\uC791 (${runId}) \xB7 ${kind} ${version}`);
+  const run = await followRun(port, runId);
+  if (run.outcomes.length === 0) console.log(noDevicesMessage);
+  const code = runExitCode(run);
+  console.log(`exit ${code}`);
+  return code;
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = exitCodes.failed;
+});

package/dist/explore-allowlist-F44YQDVK.js

@@ -0,0 +1,44 @@
+import {
+  addMissingAsDeny,
+  defaultAllowlistFile,
+  isMutatingMethod,
+  loadAllowlist
+} from "./chunk-Q6CXF3NJ.js";
+
+// apps/cli/src/explore-allowlist.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+function collectWriteOperations(spec) {
+  if (typeof spec !== "object" || spec === null || !("paths" in spec)) throw new Error("OpenAPI \uC2A4\uD399\uC5D0 paths\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  const { paths } = spec;
+  if (typeof paths !== "object" || paths === null) throw new Error("OpenAPI paths\uAC00 \uAC1D\uCCB4\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+  const operations = [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (typeof item !== "object" || item === null) continue;
+    for (const method of Object.keys(item)) {
+      const upper = method.toUpperCase();
+      if (isMutatingMethod(upper)) operations.push({ method: upper, path });
+    }
+  }
+  return operations;
+}
+async function fetchSpec(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`OpenAPI \uC2A4\uD399\uC744 \uBABB \uBC1B\uC558\uC2B5\uB2C8\uB2E4: ${response.status} ${url}`);
+  return response.json();
+}
+async function main() {
+  const url = process.env.FARM_OPENAPI_URL;
+  if (!url) throw new Error("FARM_OPENAPI_URL\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.");
+  const operations = collectWriteOperations(await fetchSpec(url));
+  const current = await loadAllowlist();
+  const { allowlist, added } = addMissingAsDeny(current, operations);
+  await mkdir(dirname(defaultAllowlistFile), { recursive: true });
+  await writeFile(defaultAllowlistFile, `${JSON.stringify(allowlist, null, 2)}
+`);
+  console.log(`\uC4F0\uAE30 API ${operations.length}\uAC1C \uC911 ${added}\uAC1C\uB97C deny\uB85C \uCD94\uAC00\uD588\uC2B5\uB2C8\uB2E4. (${defaultAllowlistFile})`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});