@autifyhq/aximo-cli 0.4.0 → 0.6.0

package/dist/mobile-control/appium-server.js

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import { createServer } from "node:net";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { getAximoDir } from "../commands/device/paths.js";
+import { importAppium } from "./appium-import.js";
+export function getAppiumHome() {
+    return join(getAximoDir(), "appium-home");
+}
+function isValidSdk(dir, exists) {
+    return exists(dir) && exists(join(dir, "platform-tools"));
+}
+/**
+ * Resolve the Android SDK location. Honours ANDROID_HOME / ANDROID_SDK_ROOT when
+ * set and valid, else probes the standard per-OS install location. Appium's
+ * UiAutomator2 driver requires this even when `adb` is already on PATH.
+ */
+export function resolveAndroidSdk(deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? homedir();
+    const os = deps.platform ?? platform();
+    const exists = deps.exists ?? existsSync;
+    for (const candidate of [env["ANDROID_HOME"], env["ANDROID_SDK_ROOT"]]) {
+        if (candidate && isValidSdk(candidate, exists))
+            return candidate;
+    }
+    const standard = os === "darwin"
+        ? join(home, "Library", "Android", "sdk")
+        : os === "win32"
+            ? join(env["LOCALAPPDATA"] ?? join(home, "AppData", "Local"), "Android", "Sdk")
+            : join(home, "Android", "Sdk");
+    return isValidSdk(standard, exists) ? standard : null;
+}
+export async function pickFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = createServer();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const address = srv.address();
+            if (address && typeof address === "object") {
+                const { port } = address;
+                srv.close(() => resolve(port));
+            }
+            else {
+                srv.close(() => reject(new Error("Could not determine a free port")));
+            }
+        });
+    });
+}
+const defaultLaunch = async (args) => {
+    const mod = await importAppium();
+    return mod.main(args);
+};
+async function pollReady(endpoint, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${endpoint}/status`);
+            if (res.ok)
+                return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+    throw new Error(`Appium server did not become ready within ${timeoutMs}ms${detail}`);
+}
+export async function startAppiumServer(options = {}) {
+    const launch = options.launch ?? defaultLaunch;
+    const appiumHome = options.appiumHome ?? getAppiumHome();
+    const useDrivers = options.useDrivers ?? ["uiautomator2"];
+    const readyTimeoutMs = options.readyTimeoutMs ?? 30_000;
+    // Appium's UiAutomator2 driver reads ANDROID_HOME/ANDROID_SDK_ROOT from the
+    // environment; it runs in-process via main(), so we export a resolved SDK
+    // path here when neither is set, otherwise sessions fail to start.
+    if (!process.env["ANDROID_HOME"] && !process.env["ANDROID_SDK_ROOT"]) {
+        const sdk = resolveAndroidSdk();
+        if (sdk) {
+            process.env["ANDROID_HOME"] = sdk;
+            process.env["ANDROID_SDK_ROOT"] = sdk;
+            console.error(`Using auto-detected Android SDK at ${sdk} (set ANDROID_HOME to override).`);
+        }
+    }
+    const port = await pickFreePort();
+    const endpoint = `http://127.0.0.1:${port}`;
+    const server = await launch({
+        port,
+        basePath: "/",
+        host: "127.0.0.1",
+        appiumHome,
+        useDrivers,
+        loglevel: "warn",
+    });
+    try {
+        await pollReady(endpoint, readyTimeoutMs);
+    }
+    catch (error) {
+        await server.close().catch(() => { });
+        throw error;
+    }
+    return {
+        endpoint,
+        stop: async () => {
+            await server.close();
+        },
+    };
+}

package/dist/mobile-control/appium-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/appium-server.test.js

@@ -0,0 +1,108 @@
+import { join } from "node:path";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import { pickFreePort, resolveAndroidSdk, startAppiumServer, } from "./appium-server.js";
+const realFetch = globalThis.fetch;
+beforeAll(() => {
+    process.env["AXIMO_HOME"] = "/tmp/aximo-appium-test";
+});
+afterEach(() => {
+    globalThis.fetch = realFetch;
+    vi.restoreAllMocks();
+});
+describe("pickFreePort", () => {
+    it("returns a usable, positive port", async () => {
+        const port = await pickFreePort();
+        expect(port).toBeGreaterThan(0);
+        expect(port).toBeLessThan(65_536);
+    });
+});
+describe("startAppiumServer", () => {
+    it("launches on a free port, polls /status, and stops", async () => {
+        let statusHits = 0;
+        globalThis.fetch = vi.fn(async (input) => {
+            const url = String(input);
+            expect(url).toContain("/status");
+            statusHits++;
+            return new Response("{}", { status: statusHits >= 2 ? 200 : 503 });
+        });
+        const close = vi.fn(async () => { });
+        const launchArgs = [];
+        const launch = async (args) => {
+            launchArgs.push(args);
+            return { close };
+        };
+        const handle = await startAppiumServer({ launch, readyTimeoutMs: 5000 });
+        expect(handle.endpoint).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/);
+        const args = launchArgs[0];
+        expect(args["host"]).toBe("127.0.0.1");
+        expect(args["basePath"]).toBe("/");
+        expect(typeof args["port"]).toBe("number");
+        expect(args["useDrivers"]).toEqual(["uiautomator2"]);
+        expect(statusHits).toBeGreaterThanOrEqual(2);
+        await handle.stop();
+        expect(close).toHaveBeenCalledOnce();
+    });
+    it("closes the server and throws when readiness times out", async () => {
+        globalThis.fetch = vi.fn(async () => new Response("nope", { status: 503 }));
+        const close = vi.fn(async () => { });
+        const launch = async () => ({ close });
+        await expect(startAppiumServer({ launch, readyTimeoutMs: 300 })).rejects.toThrow(/did not become ready/);
+        expect(close).toHaveBeenCalledOnce();
+    });
+});
+describe("resolveAndroidSdk", () => {
+    const exists = (valid) => (path) => path === valid || path === join(valid, "platform-tools");
+    it("honours a valid ANDROID_HOME", () => {
+        const result = resolveAndroidSdk({
+            env: { ANDROID_HOME: "/opt/sdk" },
+            exists: exists("/opt/sdk"),
+        });
+        expect(result).toBe("/opt/sdk");
+    });
+    it("falls back to ANDROID_SDK_ROOT when ANDROID_HOME is invalid", () => {
+        const result = resolveAndroidSdk({
+            env: { ANDROID_HOME: "/bad", ANDROID_SDK_ROOT: "/opt/root" },
+            exists: exists("/opt/root"),
+        });
+        expect(result).toBe("/opt/root");
+    });
+    it("probes the standard macOS location when env is unset", () => {
+        const expected = join("/Users/dev", "Library", "Android", "sdk");
+        const result = resolveAndroidSdk({
+            env: {},
+            home: "/Users/dev",
+            platform: "darwin",
+            exists: exists(expected),
+        });
+        expect(result).toBe(expected);
+    });
+    it("probes the standard Linux location when env is unset", () => {
+        const expected = join("/home/dev", "Android", "Sdk");
+        const result = resolveAndroidSdk({
+            env: {},
+            home: "/home/dev",
+            platform: "linux",
+            exists: exists(expected),
+        });
+        expect(result).toBe(expected);
+    });
+    it("probes LOCALAPPDATA on Windows when env is unset", () => {
+        const expected = join("C:\\Users\\dev\\AppData\\Local", "Android", "Sdk");
+        const result = resolveAndroidSdk({
+            env: { LOCALAPPDATA: "C:\\Users\\dev\\AppData\\Local" },
+            home: "C:\\Users\\dev",
+            platform: "win32",
+            exists: exists(expected),
+        });
+        expect(result).toBe(expected);
+    });
+    it("returns null when no SDK is found", () => {
+        const result = resolveAndroidSdk({
+            env: {},
+            home: "/home/dev",
+            platform: "linux",
+            exists: () => false,
+        });
+        expect(result).toBeNull();
+    });
+});

package/dist/mobile-control/controller.d.ts

@@ -0,0 +1,22 @@
+export interface ActionResult {
+    ok: boolean;
+    error?: string;
+}
+export interface MobileController {
+    screenshot(): Promise<Buffer>;
+    tap(x: number, y: number): Promise<void>;
+    doubleTap(x: number, y: number): Promise<void>;
+    longPress(x: number, y: number, durationMs: number): Promise<void>;
+    swipe(x1: number, y1: number, x2: number, y2: number, durationMs: number): Promise<void>;
+    typeText(text: string): Promise<ActionResult>;
+    pressKey(key: string): Promise<ActionResult>;
+    launchApp(app: string): Promise<ActionResult>;
+    findElement(text: string): Promise<ActionResult>;
+    clearText(): Promise<ActionResult>;
+    hideKeyboard(): Promise<ActionResult>;
+    getDeviceTime?(): Promise<{
+        datetime: string;
+        timezone: string;
+    } | null>;
+    close(): Promise<void>;
+}

package/dist/mobile-control/controller.js

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/devices.d.ts

@@ -0,0 +1,23 @@
+import { type ExecFn } from "./exec.js";
+export interface AndroidDevice {
+    serial: string;
+    state: string;
+    model?: string;
+}
+/** Parse `adb devices -l` into serial + state (+ model when present). */
+export declare function listAndroidDevices(exec?: ExecFn): Promise<AndroidDevice[]>;
+/** Resolve an adb serial: explicit (validated), else the single connected phone. */
+export declare function resolveAndroidSerial(preferred: string | undefined, exec?: ExecFn): Promise<string>;
+export interface IosPhysicalDevice {
+    udid: string;
+    name: string;
+    state?: string;
+}
+/** Resolve an iOS udid: explicit (validated), else the single connected device. */
+export declare function resolveIosUdid(preferred: string | undefined, exec?: ExecFn): Promise<string>;
+/**
+ * List physically-connected iOS devices via `idb list-targets --json` (one JSON
+ * object per line). Only entries whose `type` is `device` are returned. Returns
+ * an empty list when idb is not installed; a real idb failure is surfaced.
+ */
+export declare function listIosPhysicalDevices(exec?: ExecFn): Promise<IosPhysicalDevice[]>;

package/dist/mobile-control/devices.js

@@ -0,0 +1,129 @@
+import { execBinary } from "./exec.js";
+/** Parse `adb devices -l` into serial + state (+ model when present). */
+export async function listAndroidDevices(exec = execBinary) {
+    const { stdout } = await exec("adb", ["devices", "-l"]);
+    const lines = stdout.toString("utf-8").split("\n").slice(1);
+    const result = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const parts = line.split(/\s+/);
+        const serial = parts[0];
+        const state = parts[1];
+        if (!serial || !state)
+            continue;
+        const modelToken = parts.find((p) => p.startsWith("model:"));
+        const device = { serial, state };
+        if (modelToken)
+            device.model = modelToken.slice("model:".length);
+        result.push(device);
+    }
+    return result;
+}
+/** Resolve an adb serial: explicit (validated), else the single connected phone. */
+export async function resolveAndroidSerial(preferred, exec = execBinary) {
+    const devices = await listAndroidDevices(exec);
+    if (preferred) {
+        if (preferred.startsWith("emulator-")) {
+            throw new Error("Emulators are not supported — register a physical phone connected over USB only.");
+        }
+        const match = devices.find((d) => d.serial === preferred);
+        if (!match) {
+            throw new Error(`No Android device with serial '${preferred}' is connected.`);
+        }
+        if (match.state === "unauthorized") {
+            throw new Error("Android device is unauthorized. Accept the RSA prompt on the device, then retry.");
+        }
+        if (match.state === "offline") {
+            throw new Error("Android device is offline — reconnect the USB cable and unlock the phone.");
+        }
+        if (match.state !== "device") {
+            throw new Error(`Android device '${preferred}' is in state '${match.state}' — reconnect and unlock the phone.`);
+        }
+        return match.serial;
+    }
+    // Physical phones only: exclude emulator serials (mirrors list.ts).
+    const usable = devices.filter((d) => d.state === "device" && !d.serial.startsWith("emulator-"));
+    if (usable.length === 1 && usable[0])
+        return usable[0].serial;
+    if (usable.length === 0) {
+        const unauthorized = devices.find((d) => d.state === "unauthorized");
+        if (unauthorized) {
+            throw new Error("Android device is unauthorized. Accept the RSA prompt on the device, then retry.");
+        }
+        const offline = devices.find((d) => d.state === "offline");
+        if (offline) {
+            throw new Error("Android device is offline — reconnect the USB cable and unlock the phone.");
+        }
+        throw new Error("No connected Android devices found. Connect a phone over USB.");
+    }
+    throw new Error(`Multiple Android devices found; pass --serial. Available: ${usable
+        .map((d) => d.serial)
+        .join(", ")}`);
+}
+/** Resolve an iOS udid: explicit (validated), else the single connected device. */
+export async function resolveIosUdid(preferred, exec = execBinary) {
+    const devices = await listIosPhysicalDevices(exec);
+    if (preferred) {
+        const match = devices.find((d) => d.udid === preferred);
+        if (!match) {
+            throw new Error(`No iOS device with udid '${preferred}' is connected. ` +
+                "Connect it over USB, unlock it, and trust this computer.");
+        }
+        return match.udid;
+    }
+    if (devices.length === 1 && devices[0])
+        return devices[0].udid;
+    if (devices.length === 0) {
+        throw new Error("No connected iOS devices found. Connect an iPhone/iPad over USB, unlock it, and " +
+            "trust this computer. Verify with `idb list-targets` (or `aximo mobile doctor` if idb is missing).");
+    }
+    throw new Error(`Multiple iOS devices found; pass --udid. Available: ${devices
+        .map((d) => `${d.name} (${d.udid})`)
+        .join(", ")}`);
+}
+/** True when a spawn failed because the binary isn't installed (ENOENT). */
+function isCommandNotFound(err) {
+    if (err?.code === "ENOENT")
+        return true;
+    return err instanceof Error && /\bENOENT\b/.test(err.message);
+}
+/**
+ * List physically-connected iOS devices via `idb list-targets --json` (one JSON
+ * object per line). Only entries whose `type` is `device` are returned. Returns
+ * an empty list when idb is not installed; a real idb failure is surfaced.
+ */
+export async function listIosPhysicalDevices(exec = execBinary) {
+    let stdout;
+    try {
+        ({ stdout } = await exec("idb", ["list-targets", "--json"]));
+    }
+    catch (err) {
+        // idb not installed → "no iOS devices"; any other idb failure should surface.
+        if (isCommandNotFound(err))
+            return [];
+        throw err;
+    }
+    const result = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const entry = JSON.parse(trimmed);
+            if (entry.type === "device" &&
+                typeof entry.udid === "string" &&
+                typeof entry.name === "string") {
+                const device = { udid: entry.udid, name: entry.name };
+                if (typeof entry.state === "string")
+                    device.state = entry.state;
+                result.push(device);
+            }
+        }
+        catch {
+            // ignore non-JSON lines
+        }
+    }
+    return result;
+}

package/dist/mobile-control/devices.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/devices.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { listAndroidDevices, listIosPhysicalDevices, resolveAndroidSerial, resolveIosUdid, } from "./devices.js";
+function fixed(stdout) {
+    return async () => ({ stdout: Buffer.from(stdout), stderr: "" });
+}
+function iosTargets(...devices) {
+    return async () => ({
+        stdout: Buffer.from(devices.map((d) => JSON.stringify(d)).join("\n")),
+        stderr: "",
+    });
+}
+const PHONE = { udid: "00008030-ABC", name: "iPhone", type: "device", state: "connected" };
+const SIM = { udid: "SIM-1", name: "iPhone 15", type: "simulator", state: "Booted" };
+describe("listAndroidDevices / resolveAndroidSerial", () => {
+    it("parses adb devices -l output", async () => {
+        const exec = fixed("List of devices attached\nR1 device model:Pixel_7\nR2 unauthorized\n");
+        const devices = await listAndroidDevices(exec);
+        expect(devices).toEqual([
+            { serial: "R1", state: "device", model: "Pixel_7" },
+            { serial: "R2", state: "unauthorized" },
+        ]);
+    });
+    it("auto-selects the only online device", async () => {
+        const exec = fixed("List of devices attached\nR1 device\n");
+        await expect(resolveAndroidSerial(undefined, exec)).resolves.toBe("R1");
+    });
+    it("reports an actionable error for an unauthorized-only device", async () => {
+        const exec = fixed("List of devices attached\nR1 unauthorized\n");
+        await expect(resolveAndroidSerial(undefined, exec)).rejects.toThrow(/unauthorized/i);
+    });
+    it("rejects an explicitly-passed emulator serial", async () => {
+        const exec = fixed("List of devices attached\nemulator-5554 device\n");
+        await expect(resolveAndroidSerial("emulator-5554", exec)).rejects.toThrow(/emulator/i);
+    });
+    it("rejects an explicitly-passed unauthorized device", async () => {
+        const exec = fixed("List of devices attached\nR1 unauthorized\n");
+        await expect(resolveAndroidSerial("R1", exec)).rejects.toThrow(/unauthorized/i);
+    });
+    it("rejects an explicitly-passed offline device", async () => {
+        const exec = fixed("List of devices attached\nR1 offline\n");
+        await expect(resolveAndroidSerial("R1", exec)).rejects.toThrow(/offline/i);
+    });
+});
+describe("listIosPhysicalDevices / resolveIosUdid", () => {
+    it("returns only physical devices (ignores simulators)", async () => {
+        const devices = await listIosPhysicalDevices(iosTargets(PHONE, SIM));
+        expect(devices).toEqual([{ udid: "00008030-ABC", name: "iPhone", state: "connected" }]);
+    });
+    it("returns an empty list when idb is not installed (ENOENT)", async () => {
+        const exec = async () => {
+            throw new Error("spawn idb ENOENT");
+        };
+        await expect(listIosPhysicalDevices(exec)).resolves.toEqual([]);
+    });
+    it("surfaces a real idb failure instead of masking it as no devices", async () => {
+        const exec = async () => {
+            throw new Error("idb list-targets --json failed: could not connect to companion");
+        };
+        await expect(listIosPhysicalDevices(exec)).rejects.toThrow(/companion/);
+    });
+    it("auto-selects the only connected device", async () => {
+        await expect(resolveIosUdid(undefined, iosTargets(PHONE))).resolves.toBe("00008030-ABC");
+    });
+    it("errors when no devices are connected", async () => {
+        await expect(resolveIosUdid(undefined, iosTargets())).rejects.toThrow(/no connected ios/i);
+    });
+    it("requires --udid when multiple devices are connected", async () => {
+        const second = { ...PHONE, udid: "00008030-DEF", name: "iPad" };
+        await expect(resolveIosUdid(undefined, iosTargets(PHONE, second))).rejects.toThrow(/--udid/);
+    });
+    it("validates an explicitly-passed udid", async () => {
+        await expect(resolveIosUdid("nope", iosTargets(PHONE))).rejects.toThrow(/no ios device/i);
+        await expect(resolveIosUdid("00008030-ABC", iosTargets(PHONE))).resolves.toBe("00008030-ABC");
+    });
+});

package/dist/mobile-control/exec.d.ts

@@ -0,0 +1,6 @@
+export interface ExecResult {
+    stdout: Buffer;
+    stderr: string;
+}
+export type ExecFn = (file: string, args: string[]) => Promise<ExecResult>;
+export declare const execBinary: ExecFn;

package/dist/mobile-control/exec.js

@@ -0,0 +1,13 @@
+import { execFile } from "node:child_process";
+// Explicit argv, no shell — payloads can't inject into the local machine.
+export const execBinary = (file, args) => new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "buffer", maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const stderrText = stderr.toString("utf-8");
+        if (error) {
+            const message = stderrText.trim() || error.message;
+            reject(new Error(`${file} ${args.join(" ")} failed: ${message}`));
+            return;
+        }
+        resolve({ stdout, stderr: stderrText });
+    });
+});

package/dist/mobile-control/ios-signing.d.ts

@@ -0,0 +1,28 @@
+/**
+ * iOS WebDriverAgent signing configuration.
+ *
+ * Driving a physical iPhone goes through Appium's XCUITest driver, which builds
+ * and code-signs a WebDriverAgent (WDA) runner onto the device. That build needs
+ * an Apple Developer signing identity. These values are supplied via env vars and
+ * forwarded as XCUITest capabilities. Simulators need no signing, so the caps are
+ * only emitted when a team id is configured.
+ *
+ * The CLI-native `AXIMO_IOS_*` names take precedence; Autify's MobileLink
+ * (mobile-web) names — `XCODE_TEAM_ID` / `XCODE_SIGN_ID` / `WDA_BUNDLE_ID` — are
+ * accepted as fallbacks so an already-configured MobileLink host needs no changes.
+ */
+export interface IosSigningConfig {
+    /** Apple Developer Team ID, forwarded as `appium:xcodeOrgId`. */
+    teamId?: string;
+    /** Code-signing identity; defaults to "Apple Development". */
+    signingId: string;
+    /** WDA bundle id backed by a valid provisioning profile. */
+    wdaBundleId: string;
+    /** Optional prebuilt-WDA DerivedData path to skip per-session WDA rebuilds. */
+    derivedDataPath?: string;
+}
+type Env = Record<string, string | undefined>;
+export declare function resolveIosSigning(env?: Env): IosSigningConfig;
+/** Map signing config to XCUITest capabilities; empty unless a team id is set. */
+export declare function iosSigningCapabilities(config: IosSigningConfig): Record<string, unknown>;
+export {};

package/dist/mobile-control/ios-signing.js

@@ -0,0 +1,38 @@
+const DEFAULT_SIGNING_ID = "Apple Development";
+const DEFAULT_WDA_BUNDLE_ID = "com.facebook.WebDriverAgentRunner";
+export function resolveIosSigning(env = process.env) {
+    // AXIMO_IOS_* is CLI-native; XCODE_*/WDA_BUNDLE_ID mirror MobileLink (mobile-web).
+    const pick = (...keys) => {
+        for (const key of keys) {
+            const value = env[key]?.trim();
+            if (value)
+                return value;
+        }
+        return undefined;
+    };
+    const teamId = pick("AXIMO_IOS_TEAM_ID", "XCODE_TEAM_ID");
+    const derivedDataPath = pick("AXIMO_IOS_DERIVED_DATA_PATH");
+    const config = {
+        signingId: pick("AXIMO_IOS_SIGNING_ID", "XCODE_SIGN_ID") || DEFAULT_SIGNING_ID,
+        wdaBundleId: pick("AXIMO_IOS_WDA_BUNDLE_ID", "WDA_BUNDLE_ID") || DEFAULT_WDA_BUNDLE_ID,
+    };
+    if (teamId)
+        config.teamId = teamId;
+    if (derivedDataPath)
+        config.derivedDataPath = derivedDataPath;
+    return config;
+}
+/** Map signing config to XCUITest capabilities; empty unless a team id is set. */
+export function iosSigningCapabilities(config) {
+    if (!config.teamId)
+        return {};
+    const caps = {
+        "appium:xcodeOrgId": config.teamId,
+        "appium:xcodeSigningId": config.signingId,
+        "appium:updatedWDABundleId": config.wdaBundleId,
+        "appium:allowProvisioningDeviceRegistration": true,
+    };
+    if (config.derivedDataPath)
+        caps["appium:derivedDataPath"] = config.derivedDataPath;
+    return caps;
+}

package/dist/mobile-control/ios-signing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/ios-signing.test.js

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { iosSigningCapabilities, resolveIosSigning } from "./ios-signing.js";
+describe("resolveIosSigning", () => {
+    it("falls back to defaults when env is empty", () => {
+        const config = resolveIosSigning({});
+        expect(config).toEqual({
+            signingId: "Apple Development",
+            wdaBundleId: "com.facebook.WebDriverAgentRunner",
+        });
+        expect(config.teamId).toBeUndefined();
+    });
+    it("reads team id, signing id, wda bundle id and derived data path from env", () => {
+        const config = resolveIosSigning({
+            AXIMO_IOS_TEAM_ID: "ABCDE12345",
+            AXIMO_IOS_SIGNING_ID: "Apple Distribution",
+            AXIMO_IOS_WDA_BUNDLE_ID: "com.example.WDA",
+            AXIMO_IOS_DERIVED_DATA_PATH: "/tmp/wda",
+        });
+        expect(config).toEqual({
+            teamId: "ABCDE12345",
+            signingId: "Apple Distribution",
+            wdaBundleId: "com.example.WDA",
+            derivedDataPath: "/tmp/wda",
+        });
+    });
+    it("treats blank env values as unset", () => {
+        const config = resolveIosSigning({ AXIMO_IOS_TEAM_ID: "  " });
+        expect(config.teamId).toBeUndefined();
+    });
+    it("falls back to the MobileLink (XCODE_*/WDA_BUNDLE_ID) names", () => {
+        const config = resolveIosSigning({
+            XCODE_TEAM_ID: "ABCDE12345",
+            XCODE_SIGN_ID: "Apple Distribution",
+            WDA_BUNDLE_ID: "com.example.WDA",
+        });
+        expect(config).toEqual({
+            teamId: "ABCDE12345",
+            signingId: "Apple Distribution",
+            wdaBundleId: "com.example.WDA",
+        });
+    });
+    it("prefers AXIMO_IOS_* over the MobileLink fallbacks", () => {
+        const config = resolveIosSigning({
+            AXIMO_IOS_TEAM_ID: "AXIMO00000",
+            XCODE_TEAM_ID: "XCODE00000",
+            AXIMO_IOS_SIGNING_ID: "Apple Development",
+            XCODE_SIGN_ID: "Apple Distribution",
+        });
+        expect(config.teamId).toBe("AXIMO00000");
+        expect(config.signingId).toBe("Apple Development");
+    });
+});
+describe("iosSigningCapabilities", () => {
+    it("is empty without a team id (simulator / automatic signing)", () => {
+        expect(iosSigningCapabilities(resolveIosSigning({}))).toEqual({});
+    });
+    it("emits XCUITest signing caps when a team id is set", () => {
+        const caps = iosSigningCapabilities(resolveIosSigning({ AXIMO_IOS_TEAM_ID: "ABCDE12345" }));
+        expect(caps).toEqual({
+            "appium:xcodeOrgId": "ABCDE12345",
+            "appium:xcodeSigningId": "Apple Development",
+            "appium:updatedWDABundleId": "com.facebook.WebDriverAgentRunner",
+            "appium:allowProvisioningDeviceRegistration": true,
+        });
+    });
+    it("includes derivedDataPath when configured", () => {
+        const caps = iosSigningCapabilities(resolveIosSigning({
+            AXIMO_IOS_TEAM_ID: "ABCDE12345",
+            AXIMO_IOS_DERIVED_DATA_PATH: "/tmp/wda",
+        }));
+        expect(caps["appium:derivedDataPath"]).toBe("/tmp/wda");
+    });
+});

package/dist/mobile-control/tunnel.d.ts

@@ -0,0 +1,15 @@
+import { type Socket } from "socket.io-client";
+import type { MobileController } from "./controller.js";
+export interface RunControlTunnelOptions {
+    wsUrl: string;
+    deviceToken: string;
+    deviceName: string;
+    controller: MobileController;
+    /** Installs the app under test on the device (fetch by upload id -> adb/idb install). */
+    installApp?: (args: {
+        uploadId: string;
+    }) => Promise<void>;
+    connect?: (wsUrl: string, deviceToken: string) => Socket;
+}
+export declare function registerHandlers(socket: Socket, controller: MobileController, installApp?: RunControlTunnelOptions["installApp"]): void;
+export declare function runControlTunnel(options: RunControlTunnelOptions): Promise<void>;