qraftai-runner 0.1.0

package/dist/index.js

@@ -0,0 +1,1299 @@
+#!/usr/bin/env node
+
+// index.js
+import "dotenv/config";
+import WebSocket from "ws";
+import { createRequire } from "node:module";
+import { writeFileSync, existsSync, statSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// ../server/mobile/appiumManager.js
+import { spawn } from "node:child_process";
+var HOST = process.env.APPIUM_HOST || "127.0.0.1";
+var PORT = parseInt(process.env.APPIUM_PORT_SERVER || "4723");
+var _proc = null;
+var _readyPromise = null;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function appiumEndpoint() {
+  return { host: HOST, port: PORT };
+}
+async function isUp() {
+  try {
+    const res = await fetch(`http://${HOST}:${PORT}/status`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensureAppium() {
+  if (await isUp()) return appiumEndpoint();
+  if (_readyPromise) return _readyPromise;
+  _readyPromise = (async () => {
+    console.log(`[mobile] starting Appium server on ${HOST}:${PORT}\u2026`);
+    _proc = spawn("appium", ["--port", String(PORT), "--log-level", "error"], {
+      stdio: "ignore"
+    });
+    _proc.on("error", (e) => console.error("[mobile] appium spawn error:", e.message));
+    _proc.on("exit", () => {
+      _proc = null;
+    });
+    const deadline = Date.now() + 6e4;
+    while (Date.now() < deadline) {
+      if (await isUp()) {
+        console.log("[mobile] Appium server ready");
+        return appiumEndpoint();
+      }
+      await sleep(1e3);
+    }
+    throw new Error("Appium server did not become ready within 60s");
+  })();
+  try {
+    return await _readyPromise;
+  } finally {
+    _readyPromise = null;
+  }
+}
+function stopAppium() {
+  if (_proc) {
+    _proc.kill();
+    _proc = null;
+  }
+}
+
+// ../server/mobile/deviceRegistry.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var pexec = promisify(execFile);
+var DEFAULT_NEW_COMMAND_TIMEOUT = parseInt(process.env.APPIUM_CMD_TIMEOUT || "120");
+var MJPEG_PORT = parseInt(process.env.MOBILE_MJPEG_PORT || "9100");
+async function listIosSimulators() {
+  try {
+    const { stdout } = await pexec("xcrun", ["simctl", "list", "devices", "available", "--json"]);
+    const data = JSON.parse(stdout);
+    const out = [];
+    for (const [runtime, devs] of Object.entries(data.devices || {})) {
+      if (!/iOS/i.test(runtime)) continue;
+      const ver = (runtime.match(/iOS[ -](\d+[-.]\d+)/i)?.[1] || "").replace("-", ".");
+      for (const d of devs) {
+        if (d.isAvailable === false) continue;
+        out.push({ id: d.udid, name: d.name, os: ver, booted: d.state === "Booted" });
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function listIosRealDevices() {
+  try {
+    const { stdout } = await pexec("xcrun", ["xctrace", "list", "devices"]);
+    const out = [];
+    for (const line of stdout.split(/\r?\n/)) {
+      if (/Simulator/i.test(line)) continue;
+      const m = /^(.*?)\s+\(([\d.]+)\)\s+\(([0-9A-Fa-f-]{8,})\)\s*$/.exec(line.trim());
+      if (m) out.push({ id: m[3], name: m[1], os: m[2] });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function listAvds() {
+  const emu = process.env.ANDROID_HOME ? `${process.env.ANDROID_HOME}/emulator/emulator` : "emulator";
+  try {
+    const { stdout } = await pexec(emu, ["-list-avds"]);
+    return stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function listAdbDevices() {
+  try {
+    const { stdout } = await pexec("adb", ["devices"], { timeout: 5e3 });
+    return stdout.split(/\r?\n/).slice(1).map((l) => l.trim()).filter(Boolean).map((l) => {
+      const [serial, status] = l.split(/\s+/);
+      return { serial, status };
+    }).filter((d) => d.serial && d.status === "device");
+  } catch {
+    return [];
+  }
+}
+async function listDevicesDetailed(platform = "android") {
+  if (platform === "ios") return listIosDevicesDetailed();
+  const avds = await listAvds();
+  const adb = await listAdbDevices();
+  const real = adb.filter((d) => !d.serial.startsWith("emulator-"));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of avds) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      out.push({ id: name, label: name, kind: "avd" });
+    }
+  }
+  for (const d of real) {
+    if (!seen.has(d.serial)) {
+      seen.add(d.serial);
+      out.push({ id: d.serial, label: `${d.serial} \xB7 phone`, kind: "device" });
+    }
+  }
+  return out;
+}
+async function resolveAdbSerial(device) {
+  if (!device) return null;
+  const adb = await listAdbDevices();
+  const serials = adb.map((d) => d.serial);
+  if (serials.includes(device)) return device;
+  const want = device.replace(/_/g, " ").trim();
+  for (const serial of serials.filter((s) => s.startsWith("emulator-"))) {
+    const name = await emulatorAvdName(serial);
+    if (name && (name === device || name.replace(/_/g, " ").trim() === want)) return serial;
+  }
+  return null;
+}
+async function emulatorAvdName(serial) {
+  for (const prop of ["ro.boot.qemu.avd_name", "ro.kernel.qemu.avd_name"]) {
+    try {
+      const { stdout } = await pexec("adb", ["-s", serial, "shell", "getprop", prop], { timeout: 3e3 });
+      const name = stdout.trim();
+      if (name) return name;
+    } catch {
+    }
+  }
+  return "";
+}
+async function listInstalledApps(device) {
+  const serial = await resolveAdbSerial(device);
+  if (!serial) return [];
+  let stdout;
+  try {
+    ({ stdout } = await pexec("adb", ["-s", serial, "shell", "pm", "list", "packages", "-3"], { timeout: 8e3 }));
+  } catch {
+    return [];
+  }
+  const pkgs = stdout.split(/\r?\n/).map((l) => l.replace(/^package:/, "").trim()).filter(Boolean).sort();
+  return pkgs.map((p) => ({ package: p, label: prettyPkgLabel(p) }));
+}
+async function verifyDevice(device, appPackage) {
+  const serial = await resolveAdbSerial(device);
+  if (!serial) return { online: false };
+  let appInstalled = null;
+  if (appPackage && /^[A-Za-z0-9._]+$/.test(appPackage)) {
+    try {
+      const { stdout } = await pexec("adb", ["-s", serial, "shell", "pm", "list", "packages", appPackage], { timeout: 5e3 });
+      appInstalled = stdout.split(/\r?\n/).some((l) => l.trim() === `package:${appPackage}`);
+    } catch {
+      appInstalled = null;
+    }
+  }
+  return { online: true, serial, appInstalled };
+}
+function prettyPkgLabel(pkg) {
+  const parts = pkg.split(".").filter(Boolean);
+  let name = parts[parts.length - 1] || pkg;
+  const generic = /* @__PURE__ */ new Set(["android", "app", "application", "mobile", "client", "main", "prod", "release"]);
+  if (generic.has(name.toLowerCase()) && parts.length > 1) name = parts[parts.length - 2];
+  return name.replace(/[_-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function listIosDevicesDetailed() {
+  const sims = await listIosSimulators();
+  const real = await listIosRealDevices();
+  const out = [];
+  for (const d of real) out.push({ id: d.id, label: `${d.name} \xB7 iPhone${d.os ? ` (iOS ${d.os})` : ""}`, kind: "device", os: d.os });
+  for (const s of sims) out.push({ id: s.udid || s.id, label: `${s.name}${s.os ? ` \xB7 iOS ${s.os}` : ""}${s.booted ? " \xB7 booted" : ""}`, kind: "simulator", os: s.os });
+  return out;
+}
+var DEVICES = {
+  maruti: {
+    platform: "android",
+    automationName: "UiAutomator2",
+    avd: "maruti"
+  },
+  userPhone: {
+    platform: "android",
+    automationName: "UiAutomator2",
+    avd: "userPhone"
+    // NOTE: userPhone returns a blank framebuffer to screenshots with its
+    // default GPU mode — prefer maruti for vision/streaming work.
+  }
+};
+var DEFAULT_DEVICE = process.env.MOBILE_DEFAULT_DEVICE || "maruti";
+function buildCapabilities(deviceName, app = {}, kind = "avd", overrides = {}, platform = "android") {
+  if (platform === "ios") return buildIosCapabilities(deviceName, app, kind, overrides);
+  const caps = {
+    platformName: "Android",
+    "appium:automationName": "UiAutomator2",
+    "appium:newCommandTimeout": DEFAULT_NEW_COMMAND_TIMEOUT,
+    // Auto-grant uses `adb install -g`, which non-rooted real phones reject
+    // (no INSTALL_GRANT_RUNTIME_PERMISSIONS) — only enable it on emulators.
+    "appium:autoGrantPermissions": kind !== "device",
+    "appium:appWaitActivity": "*",
+    // Real (non-rooted) phones can't modify the hidden-API policy global settings
+    // (no WRITE_SECURE_SETTINGS) — proceed instead of failing session creation.
+    "appium:ignoreHiddenApiPolicyError": true,
+    // Live screen stream (MJPEG) for the device view — local only.
+    "appium:mjpegServerPort": MJPEG_PORT
+  };
+  if (kind === "device") {
+    caps["appium:udid"] = deviceName;
+    caps["appium:noReset"] = true;
+  } else {
+    const avd = DEVICES[deviceName]?.avd || deviceName || DEVICES[DEFAULT_DEVICE]?.avd;
+    if (!avd) throw new Error(`No AVD/device specified and no default configured`);
+    caps["appium:avd"] = avd;
+  }
+  if (app.app) {
+    caps["appium:app"] = app.app;
+  } else if (app.appPackage) {
+    caps["appium:appPackage"] = app.appPackage;
+    if (app.appActivity) caps["appium:appActivity"] = app.appActivity;
+  }
+  return { ...caps, ...overrides };
+}
+function buildIosCapabilities(deviceName, app = {}, kind = "simulator", overrides = {}) {
+  const caps = {
+    platformName: "iOS",
+    "appium:automationName": "XCUITest",
+    "appium:newCommandTimeout": DEFAULT_NEW_COMMAND_TIMEOUT,
+    "appium:autoAcceptAlerts": false,
+    // never auto-dismiss — the agent acts literally
+    // Live screen stream (MJPEG) — XCUITest serves it on this port (local only).
+    "appium:mjpegServerPort": MJPEG_PORT
+  };
+  if (kind === "device") {
+    caps["appium:udid"] = deviceName;
+    caps["appium:noReset"] = true;
+    if (process.env.IOS_TEAM_ID) caps["appium:xcodeOrgId"] = process.env.IOS_TEAM_ID;
+    caps["appium:xcodeSigningId"] = process.env.IOS_SIGNING_ID || "iPhone Developer";
+    if (process.env.IOS_WDA_BUNDLE_ID) caps["appium:updatedWDABundleId"] = process.env.IOS_WDA_BUNDLE_ID;
+  } else {
+    if (/^[0-9A-Fa-f-]{8,}$/.test(deviceName) && deviceName.includes("-")) caps["appium:udid"] = deviceName;
+    else caps["appium:deviceName"] = deviceName || "iPhone 15";
+  }
+  if (app.app) {
+    caps["appium:app"] = app.app;
+  } else if (app.appPackage) {
+    caps["appium:bundleId"] = app.appPackage;
+  }
+  return { ...caps, ...overrides };
+}
+
+// ../server/mobile/drivers/appiumDriver.js
+import { remote } from "webdriverio";
+
+// ../server/mobile/drivers/automationDriver.js
+var AutomationDriver = class {
+  /** Open a device session. */
+  async start() {
+    throw new Error("not implemented");
+  }
+  /** Tear the session down. Must be safe to call more than once. */
+  async stop() {
+    throw new Error("not implemented");
+  }
+  /** Perceive: screenshot + grounding elements + screen signature. */
+  async getSnapshot() {
+    throw new Error("not implemented");
+  }
+  /** Execute one action (see mobileActions.js for the verb set). */
+  async act(_action) {
+    throw new Error("not implemented");
+  }
+  /** Signature of the current screen, for cache keying (Phase 4). */
+  async currentScreenId() {
+    throw new Error("not implemented");
+  }
+  /** Platform string: "android" | "ios" | "web". */
+  get platform() {
+    return "unknown";
+  }
+};
+
+// ../server/mobile/appiumSnapshot.js
+function parseBounds(raw) {
+  const m = /\[(\d+),(\d+)\]\[(\d+),(\d+)\]/.exec(raw || "");
+  if (!m) return null;
+  const [x1, y1, x2, y2] = m.slice(1).map(Number);
+  return {
+    x: x1,
+    y: y1,
+    width: x2 - x1,
+    height: y2 - y1,
+    cx: Math.round((x1 + x2) / 2),
+    cy: Math.round((y1 + y2) / 2)
+  };
+}
+function iosBounds(tag) {
+  const x = Number(attr(tag, "x")), y = Number(attr(tag, "y"));
+  const w = Number(attr(tag, "width")), h = Number(attr(tag, "height"));
+  if ([x, y, w, h].some((n) => Number.isNaN(n))) return null;
+  return { x, y, width: w, height: h, cx: Math.round(x + w / 2), cy: Math.round(y + h / 2) };
+}
+function attr(tag, name) {
+  const m = new RegExp(`${name}="([^"]*)"`).exec(tag);
+  return m ? m[1] : "";
+}
+function decode(s) {
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function normalizeSnapshot(xml, { interactableOnly = false, platform = "android" } = {}) {
+  if (!xml) return [];
+  const ios = platform === "ios" || /XCUIElementType/.test(xml);
+  return ios ? normalizeIos(xml, interactableOnly) : normalizeAndroid(xml, interactableOnly);
+}
+function normalizeAndroid(xml, interactableOnly) {
+  const tags = xml.match(/<[a-zA-Z][^>]*?\/?>/g) || [];
+  const out = [];
+  for (const tag of tags) {
+    if (tag.startsWith("</") || tag.startsWith("<?")) continue;
+    const className = attr(tag, "class") || tag.replace(/^<([\w.]+).*/, "$1");
+    const text = decode(attr(tag, "text"));
+    const contentDesc = decode(attr(tag, "content-desc"));
+    const resourceId = attr(tag, "resource-id");
+    const clickable = attr(tag, "clickable") === "true";
+    const enabled = attr(tag, "enabled") !== "false";
+    const focusable = attr(tag, "focusable") === "true";
+    const bounds = parseBounds(attr(tag, "bounds"));
+    const label = text || contentDesc || resourceId.split("/").pop() || "";
+    if (interactableOnly && !clickable && !focusable && !text && !contentDesc) continue;
+    out.push({
+      index: out.length,
+      class: className,
+      text,
+      contentDesc,
+      resourceId,
+      clickable,
+      enabled,
+      focusable,
+      bounds,
+      label
+    });
+  }
+  return out;
+}
+function normalizeIos(xml, interactableOnly) {
+  const tags = xml.match(/<XCUIElementType[^>]*?\/?>/g) || [];
+  const out = [];
+  for (const tag of tags) {
+    const className = tag.replace(/^<(XCUIElementType\w+).*/, "$1");
+    const name = decode(attr(tag, "name"));
+    const labelAttr = decode(attr(tag, "label"));
+    const value = decode(attr(tag, "value"));
+    const enabled = attr(tag, "enabled") !== "false";
+    const visible = attr(tag, "visible") !== "false";
+    const accessible = attr(tag, "accessible") === "true";
+    const bounds = iosBounds(tag);
+    const text = labelAttr || value || "";
+    const label = labelAttr || name || value || "";
+    const clickable = /Button|Cell|Link|MenuItem|SegmentedControl|Switch|TabBar|StaticText|TextField|SecureTextField|SearchField/.test(className) || accessible;
+    if (interactableOnly && !visible) continue;
+    if (interactableOnly && !clickable && !text && !name) continue;
+    out.push({
+      index: out.length,
+      class: className,
+      text,
+      contentDesc: name,
+      // map name → contentDesc so downstream label logic works
+      resourceId: name,
+      // iOS has no resource-id; name is the closest stable id
+      clickable,
+      enabled,
+      focusable: accessible,
+      bounds,
+      label
+    });
+  }
+  return out;
+}
+function screenSignature(elements) {
+  const ids = [
+    ...new Set(
+      elements.map((e) => e.resourceId || e.label).filter((s) => s && s.length <= 60)
+    )
+  ].sort().slice(0, 40);
+  let h = 5381;
+  const str = ids.join("|");
+  for (let i = 0; i < str.length; i++) h = (h << 5) + h + str.charCodeAt(i) | 0;
+  return (h >>> 0).toString(36);
+}
+
+// ../server/mobile/mobileActions.js
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var SMART_WAIT = (process.env.MOBILE_SMART_WAIT ?? "1") !== "0";
+var ELEM_WAIT_MS = parseInt(process.env.MOBILE_ELEM_WAIT_MS || "1200", 10);
+var ELEM_POLL_MS = parseInt(process.env.MOBILE_ELEM_POLL_MS || "150", 10);
+var STABLE_EPS_PX = parseInt(process.env.MOBILE_ELEM_STABLE_EPS || "2", 10);
+var WDIO_CALL_MS = parseInt(process.env.MOBILE_WDIO_CALL_MS || "4000", 10);
+var ASSERT_TIMEOUT_MS = Math.max(0, parseInt(process.env.MOBILE_ASSERT_TIMEOUT_MS || "2500", 10));
+var ASSERT_POLL_MS = Math.max(50, parseInt(process.env.MOBILE_ASSERT_POLL_MS || "250", 10));
+var ASSERT_LEGACY_SOURCE = process.env.MOBILE_ASSERT_LEGACY_SOURCE === "1";
+var ASSERT_NV_WAIT = process.env.MOBILE_ASSERT_NOTVIS_WAIT === "1";
+function wdio(p, ms = WDIO_CALL_MS, label = "wdio") {
+  return Promise.race([
+    p,
+    new Promise((_, rej) => setTimeout(() => rej(new Error(`${label} timeout ${ms}ms`)), ms))
+  ]);
+}
+function isIos(driver) {
+  if (typeof driver.isIOS === "boolean") return driver.isIOS;
+  const cap = driver.capabilities?.platformName || driver.requestedCapabilities?.platformName || "";
+  return String(cap).toLowerCase() === "ios";
+}
+function selectorFor(target = {}, ios = false) {
+  if (target.accessibilityId) return `~${target.accessibilityId}`;
+  if (target.xpath) return target.xpath;
+  if (ios) {
+    if (target.label) return `-ios predicate string:label == "${esc(target.label)}" OR name == "${esc(target.label)}"`;
+    if (target.text) return `-ios predicate string:label == "${esc(target.text)}" OR name == "${esc(target.text)}" OR value == "${esc(target.text)}"`;
+    if (target.textContains) return `-ios predicate string:label CONTAINS "${esc(target.textContains)}" OR name CONTAINS "${esc(target.textContains)}" OR value CONTAINS "${esc(target.textContains)}"`;
+    if (target.className) return `-ios class chain:**/${esc(target.className)}`;
+    if (target.resourceId) return `~${esc(target.resourceId)}`;
+    return null;
+  }
+  if (target.resourceId) return `android=new UiSelector().resourceId("${esc(target.resourceId)}")`;
+  if (target.text) return `android=new UiSelector().text("${esc(target.text)}")`;
+  if (target.textContains) return `android=new UiSelector().textContains("${esc(target.textContains)}")`;
+  if (target.label) return `android=new UiSelector().text("${esc(target.label)}")`;
+  if (target.className) return `android=new UiSelector().className("${esc(target.className)}")`;
+  return null;
+}
+function esc(s) {
+  return String(s).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function selectorCandidates(target = {}, ios = false) {
+  const out = [];
+  const push = (strategy, sel) => {
+    if (sel) out.push({ strategy, sel });
+  };
+  if (target.accessibilityId) push("accessibilityId", `~${esc(target.accessibilityId)}`);
+  if (ios) {
+    if (target.resourceId) push("resourceId", `~${esc(target.resourceId)}`);
+    if (target.text) push("text", `-ios predicate string:label == "${esc(target.text)}" OR name == "${esc(target.text)}" OR value == "${esc(target.text)}"`);
+    if (target.label) push("label", `-ios predicate string:label == "${esc(target.label)}" OR name == "${esc(target.label)}"`);
+    if (target.textContains) push("textContains", `-ios predicate string:label CONTAINS "${esc(target.textContains)}" OR name CONTAINS "${esc(target.textContains)}" OR value CONTAINS "${esc(target.textContains)}"`);
+    if (target.className && /^XCUIElementType/.test(target.className)) {
+      push("className", `-ios class chain:**/${esc(target.className)}`);
+    }
+  } else {
+    if (target.resourceId) push("resourceId", `android=new UiSelector().resourceId("${esc(target.resourceId)}")`);
+    if (target.text) push("text", `android=new UiSelector().text("${esc(target.text)}")`);
+    if (target.label) push("label", `android=new UiSelector().text("${esc(target.label)}")`);
+    if (target.textContains) push("textContains", `android=new UiSelector().textContains("${esc(target.textContains)}")`);
+    if (target.className) push("className", `android=new UiSelector().className("${esc(target.className)}")`);
+  }
+  if (target.xpath) push("xpath", target.xpath);
+  return out;
+}
+function androidUiSelector(target = {}) {
+  if (target.resourceId) return `new UiSelector().resourceId("${esc(target.resourceId)}")`;
+  if (target.text) return `new UiSelector().text("${esc(target.text)}")`;
+  if (target.textContains) return `new UiSelector().textContains("${esc(target.textContains)}")`;
+  if (target.label) return `new UiSelector().text("${esc(target.label)}")`;
+  if (target.className) return `new UiSelector().className("${esc(target.className)}")`;
+  if (target.accessibilityId) return `new UiSelector().description("${esc(target.accessibilityId)}")`;
+  return null;
+}
+function describeTarget(target = {}) {
+  const k = Object.keys(target)[0];
+  return k ? `${k} "${target[k]}"` : "element";
+}
+var MobileElementError = class extends Error {
+  constructor({ code, target, tried = [], message }) {
+    super(message);
+    this.name = "MobileElementError";
+    this.code = code;
+    this.target = target;
+    this.tried = tried;
+    this.recoverable = true;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      target: this.target,
+      tried: this.tried,
+      recoverable: this.recoverable
+    };
+  }
+};
+async function waitForElementReady(el, capMs) {
+  const deadline = Date.now() + Math.max(0, capMs);
+  let lastReason = "absent";
+  let prev = null;
+  for (; ; ) {
+    let exists = false;
+    try {
+      exists = await wdio(el.isExisting(), WDIO_CALL_MS, "isExisting");
+    } catch {
+      exists = false;
+    }
+    if (!exists) {
+      lastReason = "absent";
+      prev = null;
+    } else {
+      let shown = false;
+      try {
+        shown = await wdio(el.isDisplayed(), WDIO_CALL_MS, "isDisplayed");
+      } catch {
+        shown = false;
+      }
+      if (!shown) {
+        lastReason = "hidden";
+        prev = null;
+      } else {
+        let box = null;
+        try {
+          const [loc, size] = await Promise.all([
+            wdio(el.getLocation(), WDIO_CALL_MS, "getLocation"),
+            wdio(el.getSize(), WDIO_CALL_MS, "getSize")
+          ]);
+          box = { x: loc.x, y: loc.y, w: size.width, h: size.height };
+        } catch {
+          box = null;
+        }
+        if (!box) return { ok: true, reason: "displayed" };
+        if (prev === null) {
+          prev = box;
+          return { ok: true, reason: "ready" };
+        }
+        const still = Math.abs(box.x - prev.x) <= STABLE_EPS_PX && Math.abs(box.y - prev.y) <= STABLE_EPS_PX && Math.abs(box.w - prev.w) <= STABLE_EPS_PX && Math.abs(box.h - prev.h) <= STABLE_EPS_PX;
+        if (still) return { ok: true, reason: "stable" };
+        lastReason = "unstable";
+        prev = box;
+      }
+    }
+    if (Date.now() >= deadline) break;
+    await sleep2(Math.min(ELEM_POLL_MS, Math.max(0, deadline - Date.now())));
+  }
+  return { ok: false, reason: lastReason };
+}
+async function resolveElement(driver, target) {
+  const ios = isIos(driver);
+  if (!SMART_WAIT) {
+    const sel = selectorFor(target, ios);
+    if (!sel) throw new Error("No usable selector in target: " + JSON.stringify(target));
+    const el = await driver.$(sel);
+    if (!await el.isExisting()) throw new Error(`Element not found: ${sel}`);
+    return { el, strategy: "legacy", sel };
+  }
+  const candidates = selectorCandidates(target, ios);
+  if (!candidates.length) {
+    throw new MobileElementError({
+      code: "NO_SELECTOR",
+      target,
+      tried: [],
+      message: `No usable selector in target: ${JSON.stringify(target)}`
+    });
+  }
+  const tried = [];
+  const deadline = Date.now() + ELEM_WAIT_MS;
+  while (Date.now() < deadline) {
+    for (const { strategy, sel } of candidates) {
+      let el;
+      try {
+        el = await driver.$(sel);
+      } catch {
+        tried.push({ strategy, sel, reason: "bad_selector" });
+        continue;
+      }
+      let exists = false;
+      try {
+        exists = await wdio(el.isExisting(), WDIO_CALL_MS, "isExisting");
+      } catch {
+        exists = false;
+      }
+      if (!exists) {
+        tried.push({ strategy, sel, reason: "absent" });
+        continue;
+      }
+      const ready = await waitForElementReady(el, Math.max(ELEM_POLL_MS, deadline - Date.now()));
+      if (ready.ok) return { el, strategy, sel };
+      tried.push({ strategy, sel, reason: ready.reason });
+    }
+    if (Date.now() >= deadline) break;
+    await sleep2(ELEM_POLL_MS);
+  }
+  const uniq = dedupeTried(tried);
+  const nStrat = new Set(candidates.map((c) => c.strategy)).size;
+  throw new MobileElementError({
+    code: "ELEMENT_NOT_FOUND",
+    target,
+    tried,
+    message: `Could not locate ${describeTarget(target)} \u2014 not present/displayed on the current screen (tried ${nStrat} selector${nStrat === 1 ? "" : "s"}: ${uniq}).`
+  });
+}
+function dedupeTried(tried) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t of tried) {
+    const k = `${t.strategy}:${t.reason}`;
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(k);
+    }
+  }
+  return out.join(", ");
+}
+async function resolveForAssert(driver, target) {
+  const ios = isIos(driver);
+  const candidates = SMART_WAIT ? selectorCandidates(target, ios) : selectorFor(target, ios) ? [{ strategy: "legacy", sel: selectorFor(target, ios) }] : [];
+  for (const { sel } of candidates) {
+    try {
+      const el = await driver.$(sel);
+      if (await wdio(el.isExisting(), WDIO_CALL_MS, "isExisting").catch(() => false)) return el;
+    } catch {
+    }
+  }
+  return null;
+}
+async function w3cTap(driver, x, y) {
+  await driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: Math.round(x), y: Math.round(y) }).down().pause(60).up().perform();
+}
+async function w3cLongPress(driver, x, y, ms = 800) {
+  await driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: Math.round(x), y: Math.round(y) }).down().pause(ms).up().perform();
+}
+async function w3cSwipe(driver, x1, y1, x2, y2, duration = 600) {
+  await driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: Math.round(x1), y: Math.round(y1) }).down().pause(100).move({ duration, x: Math.round(x2), y: Math.round(y2) }).pause(80).up().perform();
+}
+async function elementCenter(el, driver) {
+  const loc = await el.getLocation();
+  const size = await el.getSize();
+  return { x: loc.x + size.width / 2, y: loc.y + size.height / 2 };
+}
+async function pollAssert(check, { timeout = ASSERT_TIMEOUT_MS, interval = ASSERT_POLL_MS } = {}) {
+  const deadline = Date.now() + timeout;
+  let last = { ok: false, reason: "not evaluated" };
+  do {
+    try {
+      last = await check();
+    } catch (e) {
+      last = { ok: false, reason: e?.message || String(e) };
+    }
+    if (last.ok) return last;
+    if (Date.now() >= deadline) break;
+    await sleep2(Math.min(interval, Math.max(0, deadline - Date.now())));
+  } while (Date.now() < deadline);
+  throw new Error(last.reason || "assertion failed");
+}
+function assertNeedle(action) {
+  return action.value ?? (action.target && (action.target.text || action.target.textContains || action.target.label)) ?? "";
+}
+function textSelector(needle, ios, exact) {
+  const n = esc(needle);
+  if (ios) {
+    const op = exact ? "==" : "CONTAINS";
+    return `-ios predicate string:label ${op} "${n}" OR name ${op} "${n}" OR value ${op} "${n}"`;
+  }
+  return exact ? `android=new UiSelector().text("${n}")` : `android=new UiSelector().textContains("${n}")`;
+}
+function descSelector(needle, exact) {
+  const n = esc(needle);
+  return exact ? `android=new UiSelector().description("${n}")` : `android=new UiSelector().descriptionContains("${n}")`;
+}
+async function countDisplayed(driver, selector) {
+  let els;
+  try {
+    els = await driver.$$(selector);
+  } catch {
+    return 0;
+  }
+  let n = 0;
+  const capped = els.slice(0, 25);
+  for (const el of capped) {
+    if (await wdio(el.isDisplayed(), WDIO_CALL_MS, "isDisplayed").catch(() => false)) n++;
+  }
+  return n;
+}
+async function isTextVisible(driver, needle, { exact = false } = {}) {
+  if (!needle) return { ok: false, reason: 'assert_text: empty "value"' };
+  const ios = isIos(driver);
+  let matches = await countDisplayed(driver, textSelector(needle, ios, exact));
+  if (!matches && !ios) matches = await countDisplayed(driver, descSelector(needle, exact));
+  return matches > 0 ? { ok: true, count: matches } : { ok: false, reason: `assert_text failed: "${needle}" not visible on screen`, count: 0 };
+}
+async function clampToScreen(driver, x, y) {
+  const { width: w, height: h } = await driver.getWindowSize();
+  return {
+    x: Math.max(0, Math.min(Math.round(x), w - 1)),
+    y: Math.max(0, Math.min(Math.round(y), h - 1))
+  };
+}
+async function w3cDoubleTap(driver, x, y) {
+  const p = await clampToScreen(driver, x, y);
+  await driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: p.x, y: p.y }).down().pause(40).up().pause(120).down().pause(40).up().perform();
+}
+async function w3cDrag(driver, x1, y1, x2, y2, holdMs = 600, moveMs = 700) {
+  const a = await clampToScreen(driver, x1, y1);
+  const b = await clampToScreen(driver, x2, y2);
+  await driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: a.x, y: a.y }).down().pause(holdMs).move({ duration: 120, x: a.x + (b.x > a.x ? 6 : -6), y: a.y + (b.y > a.y ? 6 : -6) }).move({ duration: moveMs, x: b.x, y: b.y }).pause(200).up().perform();
+}
+async function w3cPinchZoom(driver, cx, cy, dir = "out", spread = 250, moveMs = 600) {
+  const half = Math.round(spread / 2);
+  const near = Math.max(10, Math.round(spread * 0.12));
+  const outer = half, inner = near;
+  const [aS, aE, bS, bE] = dir === "in" ? [outer, inner, outer, inner] : [inner, outer, inner, outer];
+  const C = await clampToScreen(driver, cx, cy);
+  const pA1 = await clampToScreen(driver, C.x - aS, C.y - aS);
+  const pA2 = await clampToScreen(driver, C.x - aE, C.y - aE);
+  const pB1 = await clampToScreen(driver, C.x + bS, C.y + bS);
+  const pB2 = await clampToScreen(driver, C.x + bE, C.y + bE);
+  const fingerA = driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: pA1.x, y: pA1.y }).down().pause(60).move({ duration: moveMs, x: pA2.x, y: pA2.y }).pause(80).up();
+  const fingerB = driver.action("pointer", { parameters: { pointerType: "touch" } }).move({ x: pB1.x, y: pB1.y }).down().pause(60).move({ duration: moveMs, x: pB2.x, y: pB2.y }).pause(80).up();
+  await driver.actions([fingerA, fingerB]);
+}
+async function gestureCenter(driver, action) {
+  if (action.coords) return await clampToScreen(driver, action.coords.x, action.coords.y);
+  if (action.target) {
+    const { el } = await resolveElement(driver, action.target);
+    const c = await elementCenter(el, driver);
+    return await clampToScreen(driver, c.x, c.y);
+  }
+  const { width: w, height: h } = await driver.getWindowSize();
+  return { x: Math.round(w / 2), y: Math.round(h / 2) };
+}
+async function executeMobileAction(driver, action) {
+  const { type } = action;
+  switch (type) {
+    case "tap": {
+      if (action.coords) {
+        await w3cTap(driver, action.coords.x, action.coords.y);
+        return { type, via: "coords" };
+      }
+      const { el, strategy } = await resolveElement(driver, action.target);
+      await el.click();
+      return { type, via: "selector", strategy };
+    }
+    case "type": {
+      const text = action.value ?? "";
+      console.log(`[mobile] type \u2192 value=${JSON.stringify(text)} target=${JSON.stringify(action.target ?? null)}`);
+      if (!text) throw new Error('type action requires a non-empty "value"');
+      if (action.target) {
+        const { el, strategy } = await resolveElement(driver, action.target);
+        if (action.clear !== false) await el.clearValue().catch(() => {
+        });
+        await el.addValue(text);
+        return { type, value: text, via: "selector", strategy };
+      }
+      await driver.keys(text);
+      return { type, value: text, via: "focused" };
+    }
+    case "longPress": {
+      const ms = action.ms ?? 800;
+      const pt = action.coords ? action.coords : await elementCenter((await resolveElement(driver, action.target)).el, driver);
+      await w3cLongPress(driver, pt.x, pt.y, ms);
+      return { type };
+    }
+    case "swipe":
+    case "scroll": {
+      const direction = (action.direction || (type === "scroll" ? "down" : "up")).toLowerCase();
+      const { width: w, height: h } = await driver.getWindowSize();
+      const cx = w / 2, cy = h / 2;
+      let x1 = cx, y1 = h * 0.7, x2 = cx, y2 = h * 0.3;
+      if (direction === "up") {
+        y1 = h * 0.3;
+        y2 = h * 0.7;
+      } else if (direction === "left") {
+        x1 = w * 0.75;
+        y1 = cy;
+        x2 = w * 0.25;
+        y2 = cy;
+      } else if (direction === "right") {
+        x1 = w * 0.25;
+        y1 = cy;
+        x2 = w * 0.75;
+        y2 = cy;
+      }
+      await w3cSwipe(driver, x1, y1, x2, y2);
+      return { type, direction };
+    }
+    case "scrollToElement": {
+      if (!action.target) throw new Error("scrollToElement requires a target");
+      const ios = isIos(driver);
+      if (!ios) {
+        const childSel = androidUiSelector(action.target);
+        if (!childSel) throw new Error("scrollToElement(android): unsupported target for UiScrollable");
+        const scrollableSel = action.scrollableResourceId ? `new UiSelector().resourceId("${esc(action.scrollableResourceId)}")` : `new UiSelector().scrollable(true).instance(0)`;
+        const sel = `android=new UiScrollable(${scrollableSel}).setMaxSearchSwipes(${action.maxSwipes ?? 20}).scrollIntoView(${childSel})`;
+        const el = await driver.$(sel);
+        if (!await el.isExisting()) throw new Error(`scrollToElement: ${describeTarget(action.target)} not found after scrolling`);
+        return { type, via: "uiscrollable" };
+      }
+      try {
+        const { el } = await resolveElement(driver, action.target);
+        await driver.execute("mobile: scroll", { element: el.elementId, toVisible: true });
+        if (await el.isDisplayed().catch(() => false)) return { type, via: "mobile:scroll:toVisible" };
+      } catch {
+      }
+      const direction = (action.direction || "down").toLowerCase();
+      const maxSwipes = action.maxSwipes ?? 20;
+      for (let i = 0; i < maxSwipes; i++) {
+        const el = await resolveForAssert(driver, action.target);
+        if (el && await el.isDisplayed().catch(() => false)) return { type, via: "mobile:scroll", swipes: i };
+        await driver.execute("mobile: scroll", { direction });
+      }
+      throw new Error(`scrollToElement: ${describeTarget(action.target)} not visible after ${maxSwipes} scrolls`);
+    }
+    case "doubleTap": {
+      const pt = action.coords ? await clampToScreen(driver, action.coords.x, action.coords.y) : await elementCenter((await resolveElement(driver, action.target)).el, driver);
+      await w3cDoubleTap(driver, pt.x, pt.y);
+      return { type, via: action.coords ? "coords" : "selector" };
+    }
+    case "pinch":
+    case "zoom": {
+      const dir = ["in", "out"].includes((action.direction || "").toLowerCase()) ? action.direction.toLowerCase() : type === "zoom" ? "out" : "in";
+      const c = await gestureCenter(driver, action);
+      await w3cPinchZoom(driver, c.x, c.y, dir, action.spread ?? 250);
+      return { type, direction: dir };
+    }
+    case "drag": {
+      let from, to;
+      if (action.from && action.to) {
+        from = action.from;
+        to = action.to;
+      } else if (action.target && action.toTarget) {
+        from = await elementCenter((await resolveElement(driver, action.target)).el, driver);
+        to = await elementCenter((await resolveElement(driver, action.toTarget)).el, driver);
+      } else if (action.target && action.to) {
+        from = await elementCenter((await resolveElement(driver, action.target)).el, driver);
+        to = action.to;
+      } else throw new Error("drag requires {from,to} points or {target,toTarget} elements");
+      await w3cDrag(driver, from.x, from.y, to.x, to.y, action.holdMs ?? 600);
+      return { type };
+    }
+    case "rotate": {
+      const raw = (action.orientation || action.value || action.direction || "").toUpperCase();
+      const orientation = raw.startsWith("LAND") ? "LANDSCAPE" : raw.startsWith("PORT") ? "PORTRAIT" : null;
+      if (!orientation) throw new Error('rotate requires orientation "LANDSCAPE" or "PORTRAIT"');
+      try {
+        await driver.setOrientation(orientation);
+      } catch (e) {
+        throw new Error(`rotate to ${orientation} failed (app may lock orientation): ${e.message}`);
+      }
+      return { type, orientation, coordsInvalidated: true };
+    }
+    case "back": {
+      if (isIos(driver)) {
+        const { width: w, height: h } = await driver.getWindowSize();
+        await w3cSwipe(driver, 4, h * 0.5, Math.round(w * 0.6), h * 0.5);
+      } else {
+        await driver.back();
+      }
+      return { type };
+    }
+    case "hideKeyboard": {
+      await driver.hideKeyboard().catch(() => {
+      });
+      return { type };
+    }
+    case "launchApp": {
+      await driver.execute("mobile: activateApp", { appId: action.appId });
+      return { type, appId: action.appId };
+    }
+    case "terminateApp": {
+      await driver.execute("mobile: terminateApp", { appId: action.appId });
+      return { type, appId: action.appId };
+    }
+    case "wait": {
+      await sleep2(Math.min(action.ms ?? 1e3, 1e4));
+      return { type, ms: action.ms ?? 1e3 };
+    }
+    case "assert_visible": {
+      const res = await pollAssert(async () => {
+        const el = await resolveForAssert(driver, action.target);
+        const ok2 = el ? await wdio(el.isDisplayed(), WDIO_CALL_MS, "isDisplayed").catch(() => false) : false;
+        return ok2 ? { ok: true } : { ok: false, reason: `assert_visible failed: ${describeTarget(action.target)} not displayed` };
+      });
+      return { type, ok: true, assertion: true, count: res.count };
+    }
+    case "assert_not_visible": {
+      const check = async () => {
+        const el = await resolveForAssert(driver, action.target);
+        const visible = el ? await wdio(el.isDisplayed(), WDIO_CALL_MS, "isDisplayed").catch(() => false) : false;
+        return visible ? { ok: false, reason: `assert_not_visible failed: ${describeTarget(action.target)} is still visible` } : { ok: true };
+      };
+      if (ASSERT_NV_WAIT) {
+        await pollAssert(check);
+      } else {
+        const r = await check();
+        if (!r.ok) throw new Error(r.reason);
+      }
+      return { type, ok: true, assertion: true };
+    }
+    case "assert_text": {
+      const needle = assertNeedle(action);
+      const exact = action.exact === true;
+      const wantCount = Number.isInteger(action.count) ? action.count : null;
+      if (ASSERT_LEGACY_SOURCE) {
+        await pollAssert(async () => {
+          const source = await driver.getPageSource();
+          const ok2 = needle !== "" && (exact ? source === needle : source.includes(needle));
+          return ok2 ? { ok: true } : { ok: false, reason: `assert_text failed: "${needle}" not on screen` };
+        });
+        return { type, ok: true, assertion: true, legacy: true };
+      }
+      const res = await pollAssert(async () => {
+        if (wantCount !== null) {
+          const ios = isIos(driver);
+          let n = await countDisplayed(driver, textSelector(needle, ios, exact));
+          if (!n && !ios) n = await countDisplayed(driver, descSelector(needle, exact));
+          return n === wantCount ? { ok: true, count: n } : { ok: false, reason: `assert_text failed: "${needle}" visible ${n}\xD7 (expected ${wantCount})`, count: n };
+        }
+        return isTextVisible(driver, needle, { exact });
+      });
+      return { type, ok: true, assertion: true, count: res.count, exact, expectedCount: wantCount };
+    }
+    case "assert_value": {
+      const expected = action.value ?? "";
+      const contains = action.match === "contains";
+      await pollAssert(async () => {
+        const el = await resolveForAssert(driver, action.target);
+        if (!el) return { ok: false, reason: `assert_value failed: ${describeTarget(action.target)} not found` };
+        let actual = "";
+        if (isIos(driver)) {
+          actual = await el.getAttribute("value").catch(() => null) ?? await el.getText().catch(() => "") ?? "";
+        } else {
+          actual = await el.getText().catch(() => "") || await el.getAttribute("text").catch(() => "") || "";
+        }
+        actual = String(actual);
+        const ok2 = contains ? actual.includes(expected) : actual === expected;
+        return ok2 ? { ok: true } : { ok: false, reason: `assert_value failed: ${describeTarget(action.target)} value is "${actual}" (expected ${contains ? "to contain " : ""}"${expected}")` };
+      });
+      return { type, ok: true, assertion: true };
+    }
+    default:
+      throw new Error(`Unsupported mobile action: ${type}`);
+  }
+}
+
+// ../server/mobile/drivers/appiumDriver.js
+var AppiumDriver = class extends AutomationDriver {
+  /**
+   * @param {object} opts
+   * @param {object} opts.capabilities - W3C/Appium caps
+   * @param {object} [opts.connection] - { protocol, hostname, port, path, user, key }
+   *                                     defaults to local Appium on 127.0.0.1:4723
+   */
+  constructor({ capabilities, connection, host, port } = {}) {
+    super();
+    this.capabilities = capabilities;
+    this.connection = connection || {
+      protocol: "http",
+      hostname: host || "127.0.0.1",
+      port: port || 4723,
+      path: "/"
+    };
+    this.driver = null;
+  }
+  get platform() {
+    return (this.capabilities?.platformName || "android").toLowerCase();
+  }
+  async start() {
+    if (this.driver) return;
+    const c = this.connection;
+    this.driver = await remote({
+      protocol: c.protocol,
+      hostname: c.hostname,
+      port: c.port,
+      path: c.path,
+      ...c.user && { user: c.user },
+      ...c.key && { key: c.key },
+      logLevel: "error",
+      connectionRetryTimeout: 3e5,
+      // cloud real-device allocation can be slow
+      capabilities: this.capabilities
+    });
+  }
+  async stop() {
+    if (!this.driver) return;
+    const d = this.driver;
+    this.driver = null;
+    await d.deleteSession().catch(() => {
+    });
+  }
+  _assert() {
+    if (!this.driver) throw new Error("AppiumDriver not started");
+  }
+  async screenshot() {
+    this._assert();
+    return this.driver.takeScreenshot();
+  }
+  async source() {
+    this._assert();
+    return this.driver.getPageSource();
+  }
+  async getSnapshot() {
+    this._assert();
+    const screenshot = await this.screenshot();
+    let elements = [];
+    try {
+      elements = normalizeSnapshot(await this.source(), { interactableOnly: true, platform: this.platform });
+    } catch (e) {
+      console.warn("[mobile] getPageSource failed, proceeding screenshot-only:", e.message);
+    }
+    return { screenshot, elements, screenId: screenSignature(elements) };
+  }
+  async currentScreenId() {
+    const elements = normalizeSnapshot(await this.source(), { interactableOnly: true, platform: this.platform });
+    return screenSignature(elements);
+  }
+  async act(action) {
+    this._assert();
+    return executeMobileAction(this.driver, action);
+  }
+  /** Begin screen recording (best-effort). */
+  async startRecording() {
+    this._assert();
+    try {
+      await this.driver.startRecordingScreen({
+        forceRestart: true,
+        timeLimit: 1800,
+        bitRate: parseInt(process.env.MOBILE_REC_BITRATE || "1500000")
+      });
+      return true;
+    } catch (e) {
+      console.warn("[mobile] startRecordingScreen failed:", e.message);
+      return false;
+    }
+  }
+  /** Stop recording and return the base64 mp4 (or null on failure). */
+  async stopRecording() {
+    if (!this.driver) return null;
+    try {
+      return await this.driver.stopRecordingScreen();
+    } catch (e) {
+      console.warn("[mobile] stopRecordingScreen failed:", e.message);
+      return null;
+    }
+  }
+};
+
+// index.js
+var VERSION = (() => {
+  const req = createRequire(import.meta.url);
+  for (const p of ["./package.json", "../package.json"]) {
+    try {
+      return req(p).version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+})();
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--server" || a === "-s") out.server = argv[++i];
+    else if (a === "--token" || a === "-t") out.token = argv[++i];
+    else if (a === "--name" || a === "-n") out.name = argv[++i];
+    else if (a === "--help" || a === "-h") out.help = true;
+  }
+  return out;
+}
+var args = parseArgs(process.argv.slice(2));
+if (args.help) {
+  console.log(`QraftAI Runner v${VERSION}
+Bridges a local Android device/emulator to your QraftAI workspace.
+
+Usage:
+  qraftai-runner --server <wss-url> --token <token> [--name <label>]
+
+Options:
+  -s, --server   wss://<your-qraftai-host>/runner-stream   (or QRAFTAI_SERVER)
+  -t, --token    org-scoped runner token from the Mobile tab (or QRAFTAI_TOKEN)
+  -n, --name     a label shown in the app for this machine   (or QRAFTAI_RUNNER_NAME)
+
+Prerequisites (on this machine): JDK 17+, Android SDK (adb + emulator),
+Appium 2 + uiautomator2, and a device (AVD or USB phone with USB debugging).`);
+  process.exit(0);
+}
+var SERVER = args.server || process.env.QRAFTAI_SERVER;
+var TOKEN = args.token || process.env.QRAFTAI_TOKEN;
+var NAME = args.name || process.env.QRAFTAI_RUNNER_NAME || "";
+if (!SERVER || !TOKEN) {
+  console.error("\u2716  --server and --token are required (or QRAFTAI_SERVER / QRAFTAI_TOKEN).");
+  console.error("   Get them from the QraftAI Mobile tab \u2192 Local \u2192 Connect your machine.");
+  process.exit(1);
+}
+var sessions = /* @__PURE__ */ new Map();
+var sessionChains = /* @__PURE__ */ new Map();
+var ws = null;
+var reconnectDelay = 2e3;
+var MAX_RECONNECT_DELAY = 3e4;
+var closing = false;
+function sendMsg(type, payload = {}, reqId) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type, payload, ...reqId && { reqId } }));
+  }
+}
+var ok = (reqId, result) => sendMsg("RESULT", { result }, reqId);
+var err = (reqId, message) => sendMsg("ERROR", { message }, reqId);
+var HANDLERS = {
+  async OPEN_SESSION({ sessionId, device, kind = "avd", platform = "android", app }) {
+    if (sessions.has(sessionId)) return { platform: sessions.get(sessionId).platform };
+    const resolvedApp = await resolveApp(app);
+    const { host, port } = await ensureAppium();
+    const capabilities = buildCapabilities(device, resolvedApp, kind, {}, platform);
+    const driver = new AppiumDriver({
+      capabilities,
+      connection: { protocol: "http", hostname: host, port, path: "/" }
+    });
+    await driver.start();
+    sessions.set(sessionId, driver);
+    console.log(`\u25B6 session ${sessionId} started (${platform} ${kind}: ${device || "default"})`);
+    return { platform: driver.platform };
+  },
+  async LIST_APPS({ device }) {
+    return { apps: await listInstalledApps(device) };
+  },
+  async VERIFY_DEVICE({ device, appPackage }) {
+    return verifyDevice(device, appPackage);
+  },
+  async SNAPSHOT({ sessionId }) {
+    return driverFor(sessionId).getSnapshot();
+  },
+  async ACT({ sessionId, action }) {
+    return driverFor(sessionId).act(action);
+  },
+  async SCREEN_ID({ sessionId }) {
+    return { screenId: await driverFor(sessionId).currentScreenId() };
+  },
+  async START_REC({ sessionId }) {
+    return { ok: await driverFor(sessionId).startRecording() };
+  },
+  async STOP_REC({ sessionId }) {
+    return { mp4: await driverFor(sessionId).stopRecording() };
+  },
+  async CLOSE_SESSION({ sessionId }) {
+    const d = sessions.get(sessionId);
+    if (d) {
+      sessions.delete(sessionId);
+      await d.stop().catch(() => {
+      });
+      console.log(`\u25A0 session ${sessionId} ended`);
+    }
+    sessionChains.delete(sessionId);
+    return { ok: true };
+  },
+  async LIST_DEVICES({ platform = "android" }) {
+    return { devices: await listDevicesDetailed(platform) };
+  }
+};
+function driverFor(sessionId) {
+  const d = sessions.get(sessionId);
+  if (!d) throw new Error(`no such session: ${sessionId}`);
+  return d;
+}
+function runSerialized(sessionId, fn) {
+  const prev = sessionChains.get(sessionId) || Promise.resolve();
+  const next = prev.then(() => fn(), () => fn());
+  sessionChains.set(sessionId, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+async function resolveApp(app) {
+  if (!app) return {};
+  if (app.apkId && app.downloadToken) return { app: await ensureApk(app.apkId, app.downloadToken) };
+  if (app.appPackage) return { appPackage: app.appPackage, appActivity: app.appActivity };
+  if (app.app) return { app: app.app };
+  return {};
+}
+var APK_CACHE = join(tmpdir(), "qraftai-runner-apks");
+var API_BASE = SERVER.replace(/^ws/i, "http").replace(/\/runner-stream.*$/i, "");
+async function ensureApk(apkId, token) {
+  mkdirSync(APK_CACHE, { recursive: true });
+  const dest = join(APK_CACHE, `${apkId}.apk`);
+  if (existsSync(dest) && statSync(dest).size > 0) return dest;
+  const url = `${API_BASE}/api/mobile/runner-apk/${encodeURIComponent(apkId)}?t=${encodeURIComponent(token)}`;
+  console.log(`\u21E9 downloading app ${apkId}\u2026`);
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`app download failed (HTTP ${res.status})`);
+  writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+  console.log(`\u21E9 app ready (${Math.round(statSync(dest).size / 1048576)} MB)`);
+  return dest;
+}
+async function reportDevices() {
+  for (const platform of ["android"]) {
+    try {
+      const devices = await listDevicesDetailed(platform);
+      sendMsg("DEVICES", { platform, devices });
+    } catch {
+    }
+  }
+}
+function connect() {
+  const sep = SERVER.includes("?") ? "&" : "?";
+  const url = `${SERVER}${sep}token=${encodeURIComponent(TOKEN)}${NAME ? `&name=${encodeURIComponent(NAME)}` : ""}`;
+  console.log(`\u2026 connecting to ${SERVER}`);
+  ws = new WebSocket(url);
+  ws.on("open", async () => {
+    reconnectDelay = 2e3;
+    console.log(`\u2705 connected to QraftAI${NAME ? ` as "${NAME}"` : ""}`);
+    sendMsg("HELLO", { version: VERSION, name: NAME, platforms: ["android"] });
+    await reportDevices();
+  });
+  ws.on("message", async (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    const { type, payload = {}, reqId } = msg;
+    if (type === "REGISTERED") {
+      console.log(`   registered (runner id: ${payload.runnerId})`);
+      return;
+    }
+    if (type === "ERROR" && !reqId) {
+      console.error(`\u2716 server: ${payload.message || "error"}`);
+      return;
+    }
+    const handler = HANDLERS[type];
+    if (!handler) {
+      if (reqId) err(reqId, `unknown method: ${type}`);
+      return;
+    }
+    const sid = payload?.sessionId;
+    try {
+      const result = await (sid ? runSerialized(sid, () => handler(payload)) : handler(payload));
+      ok(reqId, result);
+    } catch (e) {
+      console.error(`\u2716 ${type} failed: ${e.message}`);
+      err(reqId, e.message);
+    }
+  });
+  ws.on("close", async (code) => {
+    for (const [id, d] of sessions) {
+      sessions.delete(id);
+      await d.stop().catch(() => {
+      });
+    }
+    sessionChains.clear();
+    if (closing) return;
+    if (code === 4401) {
+      console.error("\u2716 authentication failed \u2014 the token is invalid or expired. Get a fresh one from the Mobile tab.");
+      process.exit(1);
+    }
+    console.warn(`\u2026 disconnected (code ${code}); reconnecting in ${Math.round(reconnectDelay / 1e3)}s`);
+    setTimeout(connect, reconnectDelay);
+    reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY);
+  });
+  ws.on("error", (e) => console.warn(`\u2026 socket error: ${e.message}`));
+}
+async function shutdown() {
+  closing = true;
+  console.log("\n\u2026 shutting down runner");
+  for (const [, d] of sessions) await d.stop().catch(() => {
+  });
+  try {
+    ws?.close();
+  } catch {
+  }
+  stopAppium();
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+connect();