@autifyhq/aximo-cli 0.3.0 → 0.5.0

package/dist/desktop-server/setup-tls.test.js

@@ -0,0 +1,83 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveAgentSslCertFile, writeCertBundle } from "./setup.js";
+let tempDir;
+const savedEnv = {};
+beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "aximo-tls-"));
+    for (const key of ["SSL_CERT_FILE", "NODE_EXTRA_CA_CERTS", "AXIMO_HOME"]) {
+        savedEnv[key] = process.env[key];
+        delete process.env[key];
+    }
+    process.env["AXIMO_HOME"] = tempDir;
+});
+afterEach(() => {
+    for (const [key, value] of Object.entries(savedEnv)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    rmSync(tempDir, { recursive: true, force: true });
+    vi.doUnmock("node:child_process");
+    vi.resetModules();
+});
+describe("writeCertBundle", () => {
+    it("concatenates certifi roots and the custom CA into one bundle", () => {
+        const certifi = join(tempDir, "certifi.pem");
+        const customCa = join(tempDir, "ca.pem");
+        const out = join(tempDir, "bundle.pem");
+        writeFileSync(certifi, "-----CERTIFI ROOT-----\n");
+        writeFileSync(customCa, "-----AXIMO CA-----\n");
+        writeCertBundle(out, certifi, customCa);
+        const result = readFileSync(out, "utf-8");
+        expect(result).toContain("-----CERTIFI ROOT-----");
+        expect(result).toContain("-----AXIMO CA-----");
+        // certifi first, custom CA second, single trailing newline
+        expect(result).toBe("-----CERTIFI ROOT-----\n-----AXIMO CA-----\n");
+    });
+});
+describe("resolveAgentSslCertFile", () => {
+    it("respects an explicit SSL_CERT_FILE override", () => {
+        process.env["SSL_CERT_FILE"] = "/custom/bundle.pem";
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "ca.pem");
+        writeFileSync(join(tempDir, "ca.pem"), "ca");
+        expect(resolveAgentSslCertFile("/no/python")).toBe("/custom/bundle.pem");
+    });
+    it("returns undefined when no custom CA is configured (public-CA servers)", () => {
+        expect(resolveAgentSslCertFile("/no/python")).toBeUndefined();
+    });
+    it("returns undefined when NODE_EXTRA_CA_CERTS points at a missing file", () => {
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "does-not-exist.pem");
+        expect(resolveAgentSslCertFile("/no/python")).toBeUndefined();
+    });
+    it("degrades gracefully (no throw) when the embedded certifi store can't be located", () => {
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "ca.pem");
+        writeFileSync(join(tempDir, "ca.pem"), "-----AXIMO CA-----\n");
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        // A non-existent python makes `python -m certifi` fail, so no bundle is built.
+        expect(resolveAgentSslCertFile(join(tempDir, "no-such-python"))).toBeUndefined();
+        expect(errSpy).toHaveBeenCalled();
+        errSpy.mockRestore();
+    });
+    it("builds and returns the certifi+CA bundle when a custom CA and certifi store are present", async () => {
+        const certifiPath = join(tempDir, "certifi.pem");
+        const customCaPath = join(tempDir, "ca.pem");
+        writeFileSync(certifiPath, "-----CERTIFI ROOT-----\n");
+        writeFileSync(customCaPath, "-----AXIMO CA-----\n");
+        process.env["NODE_EXTRA_CA_CERTS"] = customCaPath;
+        // Stub `python -m certifi` so it resolves to the fixture certifi store above.
+        vi.resetModules();
+        vi.doMock("node:child_process", () => ({
+            spawn: vi.fn(),
+            spawnSync: vi.fn(() => ({ status: 0, stdout: `${certifiPath}\n` })),
+        }));
+        const { resolveAgentSslCertFile: resolve } = await import("./setup.js");
+        const bundlePath = resolve("/fake/python");
+        expect(bundlePath).toBe(join(tempDir, "agent-ca-bundle.pem"));
+        // The bundle is the certifi roots followed by the custom CA, in that order.
+        expect(readFileSync(bundlePath, "utf-8")).toBe("-----CERTIFI ROOT-----\n-----AXIMO CA-----\n");
+    });
+});

package/dist/desktop-server/setup.d.ts

@@ -15,5 +15,22 @@ interface RemoteOptions {
     deviceToken: string;
     deviceName: string;
 }
+/** Path to the embedded interpreter's certifi CA store, or undefined if unavailable. */
+export declare function embeddedCertifiPath(pythonPath: string): string | undefined;
+/** Write a combined trust store (certifi roots followed by the custom CA) to outPath. */
+export declare function writeCertBundle(outPath: string, certifiPath: string, customCaPath: string): void;
+/**
+ * Resolve the SSL_CERT_FILE for the Python desktop agent.
+ *
+ * The Node CLI trusts a custom CA (e.g. an on-prem self-signed server) via
+ * NODE_EXTRA_CA_CERTS, but Python ignores that variable, so the agent's wss://
+ * relay connection would fail verification. Mirror the trust by building a
+ * bundle of the embedded interpreter's certifi roots PLUS the custom CA and
+ * pointing SSL_CERT_FILE at it. SSL_CERT_FILE replaces the whole trust store, so
+ * the bundle must contain both — the custom CA alone would break every other TLS
+ * the agent does. No-op when no custom CA is configured (public-CA servers
+ * already verify via certifi).
+ */
+export declare function resolveAgentSslCertFile(pythonPath: string): string | undefined;
 export declare function startDesktopRemote(pythonPath: string, scriptPath: string, options: RemoteOptions): ChildProcess;
 export {};

package/dist/desktop-server/setup.js

@@ -5,7 +5,7 @@ import { arch as osArch, platform } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { getAximoDir, getCacheDir, getDepsMarkerPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "../commands/device/paths.js";
+import { getAgentCaBundlePath, getAximoDir, getCacheDir, getDepsMarkerPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "../commands/device/paths.js";
 import { ensureAgent } from "./agent-sync.js";
 export const PYTHON_RELEASE = "20260414";
 export const PYTHON_VERSION = "3.12.13";
@@ -174,7 +174,58 @@ export async function ensurePythonReady(deps) {
         agentChanged: agent.changed,
     };
 }
+/** Path to the embedded interpreter's certifi CA store, or undefined if unavailable. */
+export function embeddedCertifiPath(pythonPath) {
+    const result = spawnSync(pythonPath, ["-m", "certifi"], { encoding: "utf-8" });
+    if (result.status !== 0)
+        return undefined;
+    const path = (result.stdout ?? "").trim();
+    return path && existsSync(path) ? path : undefined;
+}
+/** Write a combined trust store (certifi roots followed by the custom CA) to outPath. */
+export function writeCertBundle(outPath, certifiPath, customCaPath) {
+    const certifi = readFileSync(certifiPath, "utf-8");
+    const customCa = readFileSync(customCaPath, "utf-8");
+    writeFileSync(outPath, `${certifi.trimEnd()}\n${customCa.trimEnd()}\n`, { mode: 0o644 });
+}
+/**
+ * Resolve the SSL_CERT_FILE for the Python desktop agent.
+ *
+ * The Node CLI trusts a custom CA (e.g. an on-prem self-signed server) via
+ * NODE_EXTRA_CA_CERTS, but Python ignores that variable, so the agent's wss://
+ * relay connection would fail verification. Mirror the trust by building a
+ * bundle of the embedded interpreter's certifi roots PLUS the custom CA and
+ * pointing SSL_CERT_FILE at it. SSL_CERT_FILE replaces the whole trust store, so
+ * the bundle must contain both — the custom CA alone would break every other TLS
+ * the agent does. No-op when no custom CA is configured (public-CA servers
+ * already verify via certifi).
+ */
+export function resolveAgentSslCertFile(pythonPath) {
+    // Respect an explicit override — the user may already point Python at a bundle.
+    if (process.env["SSL_CERT_FILE"])
+        return process.env["SSL_CERT_FILE"];
+    const customCa = process.env["NODE_EXTRA_CA_CERTS"];
+    if (!customCa || !existsSync(customCa))
+        return undefined;
+    const certifiPath = embeddedCertifiPath(pythonPath);
+    if (!certifiPath) {
+        console.error("[remote] NODE_EXTRA_CA_CERTS is set but the embedded Python's certifi store " +
+            "could not be located; the desktop agent may fail TLS verification against a " +
+            "custom-CA server. Set SSL_CERT_FILE to a certifi+CA bundle to override.");
+        return undefined;
+    }
+    try {
+        const bundlePath = getAgentCaBundlePath();
+        writeCertBundle(bundlePath, certifiPath, customCa);
+        return bundlePath;
+    }
+    catch (err) {
+        console.error(`[remote] Failed to build the agent CA bundle: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
 export function startDesktopRemote(pythonPath, scriptPath, options) {
+    const sslCertFile = resolveAgentSslCertFile(pythonPath);
     const child = spawn(pythonPath, [scriptPath], {
         env: {
             ...process.env,
@@ -183,6 +234,7 @@ export function startDesktopRemote(pythonPath, scriptPath, options) {
             RELAY_URL: options.relayUrl,
             DEVICE_TOKEN: options.deviceToken,
             DEVICE_NAME: options.deviceName,
+            ...(sslCertFile ? { SSL_CERT_FILE: sslCertFile } : {}),
         },
         stdio: "pipe",
     });

package/dist/index.d.ts

@@ -3,6 +3,9 @@ export { getApiKey, getBaseUrl, request } from "./client.js";
 export { runCaseCreate } from "./commands/case/create.js";
 export { runDeviceList } from "./commands/device/list.js";
 export { runHealthCheck } from "./commands/health/check.js";
+export { runMobileList } from "./commands/mobile/list.js";
+export { runMobileRegister } from "./commands/mobile/register.js";
+export { runMobileDoctor } from "./commands/mobile/doctor.js";
 export { runPlanAddCase } from "./commands/plan/add-case.js";
 export { runPlanCreate } from "./commands/plan/create.js";
 export { runPlanRemoveCase } from "./commands/plan/remove-case.js";

package/dist/index.js

@@ -2,6 +2,9 @@ export { getApiKey, getBaseUrl, request } from "./client.js";
 export { runCaseCreate } from "./commands/case/create.js";
 export { runDeviceList } from "./commands/device/list.js";
 export { runHealthCheck } from "./commands/health/check.js";
+export { runMobileList } from "./commands/mobile/list.js";
+export { runMobileRegister } from "./commands/mobile/register.js";
+export { runMobileDoctor } from "./commands/mobile/doctor.js";
 export { runPlanAddCase } from "./commands/plan/add-case.js";
 export { runPlanCreate } from "./commands/plan/create.js";
 export { runPlanRemoveCase } from "./commands/plan/remove-case.js";

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

@@ -0,0 +1,39 @@
+import type { ActionResult, MobileController } from "./controller.js";
+import { type WebDriverTransport } from "./webdriver.js";
+export interface AppiumControllerOptions {
+    endpoint: string;
+    platform: "ios" | "android";
+    target: string;
+    transport?: WebDriverTransport;
+}
+export declare class AppiumController implements MobileController {
+    private readonly session;
+    private readonly platform;
+    private readonly target;
+    private sessionReady;
+    private scaling;
+    constructor(opts: AppiumControllerOptions);
+    private capabilities;
+    private ensureSession;
+    private scale;
+    private toPoint;
+    private pointerAction;
+    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>;
+    private performPointer;
+    typeText(text: string): Promise<ActionResult>;
+    clearText(): Promise<ActionResult>;
+    pressKey(key: string): Promise<ActionResult>;
+    launchApp(app: string): Promise<ActionResult>;
+    findElement(text: string): Promise<ActionResult>;
+    private locate;
+    hideKeyboard(): Promise<ActionResult>;
+    getDeviceTime(): Promise<{
+        datetime: string;
+        timezone: string;
+    } | null>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,367 @@
+import { fetchTransport, WebDriverSession } from "./webdriver.js";
+const ANDROID_KEY_CODES = {
+    enter: 66,
+    delete: 67,
+    tab: 61,
+    space: 62,
+    escape: 111,
+    back: 4,
+    home: 3,
+};
+const ANDROID_KEYCODE_A = 29;
+const ANDROID_META_CTRL_ON = 4096;
+const IOS_BUTTONS = {
+    home: "home",
+};
+const W3C_KEYS = {
+    enter: "\uE007",
+    delete: "\uE003",
+    tab: "\uE004",
+    escape: "\uE00C",
+    space: " ",
+};
+export class AppiumController {
+    session;
+    platform;
+    target;
+    sessionReady = null;
+    scaling = null;
+    constructor(opts) {
+        this.platform = opts.platform;
+        this.target = opts.target;
+        const transport = opts.transport ?? fetchTransport(opts.endpoint);
+        this.session = new WebDriverSession(transport);
+    }
+    capabilities() {
+        if (this.platform === "android") {
+            return {
+                platformName: "Android",
+                "appium:automationName": "UiAutomator2",
+                "appium:udid": this.target,
+                "appium:noReset": true,
+                "appium:autoLaunch": false,
+                "appium:newCommandTimeout": 0,
+            };
+        }
+        return {
+            platformName: "iOS",
+            "appium:automationName": "XCUITest",
+            "appium:udid": this.target,
+            "appium:newCommandTimeout": 0,
+        };
+    }
+    ensureSession() {
+        if (!this.sessionReady) {
+            this.sessionReady = this.session
+                .createSession(this.capabilities())
+                .then(() => undefined)
+                .catch((err) => {
+                this.sessionReady = null;
+                throw err;
+            });
+        }
+        return this.sessionReady;
+    }
+    // Incoming pixel coords scale to logical points: iOS divides by DPR, Android ~= 1.
+    async scale() {
+        if (this.scaling)
+            return this.scaling.scale;
+        const [rect, shot] = await Promise.all([this.session.windowRect(), this.session.screenshot()]);
+        const pixelWidth = readPngWidth(shot);
+        const scale = rect.width > 0 && pixelWidth > 0 ? pixelWidth / rect.width : 1;
+        this.scaling = { scale: scale > 0 ? scale : 1 };
+        return this.scaling.scale;
+    }
+    async toPoint(x, y) {
+        const s = await this.scale();
+        return [Math.round(x / s), Math.round(y / s)];
+    }
+    pointerAction(actions) {
+        return [
+            {
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions,
+            },
+        ];
+    }
+    async screenshot() {
+        await this.ensureSession();
+        return this.session.screenshot();
+    }
+    async tap(x, y) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async doubleTap(x, y) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async longPress(x, y, durationMs) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: Math.max(0, Math.round(durationMs)) },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async swipe(x1, y1, x2, y2, durationMs) {
+        await this.ensureSession();
+        const [px1, py1] = await this.toPoint(x1, y1);
+        const [px2, py2] = await this.toPoint(x2, y2);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px1, y: py1 },
+            { type: "pointerDown", button: 0 },
+            { type: "pointerMove", duration: Math.max(0, Math.round(durationMs)), x: px2, y: py2 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async performPointer(actions) {
+        await this.session.performActions(this.pointerAction(actions));
+        await this.session.releaseActions();
+    }
+    async typeText(text) {
+        await this.ensureSession();
+        try {
+            if (this.platform === "android") {
+                await this.session.execute("mobile: type", [{ text }]);
+                return { ok: true };
+            }
+            await this.session.setValueOnActiveElement(text);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async clearText() {
+        await this.ensureSession();
+        try {
+            const active = await this.session.getActiveElement();
+            if (active) {
+                await this.session.elementClear(active);
+                return { ok: true };
+            }
+        }
+        catch { }
+        if (this.platform === "android") {
+            try {
+                await this.session.execute("mobile: pressKey", [
+                    { keycode: ANDROID_KEYCODE_A, metastate: ANDROID_META_CTRL_ON },
+                ]);
+                await this.session.execute("mobile: pressKey", [{ keycode: ANDROID_KEY_CODES["delete"] }]);
+                return { ok: true };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        }
+        return {
+            ok: false,
+            error: "Could not clear the field: no focused input element was found. " +
+                "Tap the field to focus it before calling clear_text.",
+        };
+    }
+    async pressKey(key) {
+        await this.ensureSession();
+        const normalized = key.toLowerCase().trim();
+        try {
+            if (this.platform === "android") {
+                const code = ANDROID_KEY_CODES[normalized];
+                if (code === undefined)
+                    return { ok: false, error: `Unsupported key: ${key}` };
+                await this.session.execute("mobile: pressKey", [{ keycode: code }]);
+                return { ok: true };
+            }
+            if (normalized === "back") {
+                return {
+                    ok: false,
+                    error: '"back" key is Android-only. On iOS, tap the back button in the UI instead.',
+                };
+            }
+            const button = IOS_BUTTONS[normalized];
+            if (button) {
+                await this.session.execute("mobile: pressButton", [{ name: button }]);
+                return { ok: true };
+            }
+            const w3c = W3C_KEYS[normalized];
+            if (w3c) {
+                await this.session.performActions([
+                    {
+                        type: "key",
+                        id: "keyboard",
+                        actions: [
+                            { type: "keyDown", value: w3c },
+                            { type: "keyUp", value: w3c },
+                        ],
+                    },
+                ]);
+                await this.session.releaseActions();
+                return { ok: true };
+            }
+            return { ok: false, error: `Unsupported key: ${key}` };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async launchApp(app) {
+        if (!app)
+            return { ok: false, error: "launch_app requires an app id" };
+        await this.ensureSession();
+        try {
+            const param = this.platform === "android" ? { appId: app } : { bundleId: app };
+            await this.session.execute("mobile: activateApp", [param]);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async findElement(text) {
+        if (!text)
+            return { ok: false, error: "find_element requires text" };
+        await this.ensureSession();
+        try {
+            const ref = await this.locate(text);
+            if (!ref)
+                return { ok: false, error: `Element with text "${text}" not found` };
+            await this.session.elementClick(ref);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async locate(text) {
+        const strategies = this.platform === "android" ? androidStrategies(text) : iosStrategies(text);
+        for (const [using, value] of strategies) {
+            try {
+                const ref = await this.session.findElement(using, value);
+                if (ref)
+                    return ref;
+            }
+            catch { }
+        }
+        return null;
+    }
+    async hideKeyboard() {
+        await this.ensureSession();
+        try {
+            await this.session.execute("mobile: hideKeyboard", []);
+            return { ok: true };
+        }
+        catch {
+            return { ok: true };
+        }
+    }
+    async getDeviceTime() {
+        await this.ensureSession();
+        try {
+            const raw = await this.session.execute("mobile: getDeviceTime", []);
+            if (typeof raw !== "string" || raw.trim().length === 0)
+                return null;
+            const parsed = new Date(raw);
+            if (Number.isNaN(parsed.getTime()))
+                return null;
+            return {
+                datetime: humanizeDateTime(parsed),
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async close() {
+        try {
+            await this.session.deleteSession();
+        }
+        catch { }
+    }
+}
+// Builds an XPath string literal that is safe even when `s` contains single quotes.
+function xpathLiteral(s) {
+    if (!s.includes("'"))
+        return `'${s}'`;
+    const parts = s.split("'").map((part) => `'${part}'`);
+    return `concat(${parts.join(`, "'", `)})`;
+}
+// Escapes backslashes and double quotes for a Java UiSelector string argument.
+function uiSelectorLiteral(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+// Escapes single quotes for an iOS NSPredicate string literal.
+function iosPredicateLiteral(s) {
+    return s.replace(/'/g, "\\'");
+}
+function androidStrategies(text) {
+    const lower = text.toLowerCase();
+    return [
+        ["accessibility id", text],
+        ["id", text],
+        ["xpath", `//*[@text=${xpathLiteral(text)}]`],
+        [
+            "xpath",
+            `//*[contains(translate(@text, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), ${xpathLiteral(lower)})]`,
+        ],
+        ["xpath", `//*[@content-desc=${xpathLiteral(text)}]`],
+        ["xpath", `//*[contains(@content-desc, ${xpathLiteral(text)})]`],
+        ["-android uiautomator", `new UiSelector().textContains("${uiSelectorLiteral(text)}")`],
+    ];
+}
+function iosStrategies(text) {
+    const v = iosPredicateLiteral(text);
+    return [
+        ["-ios predicate string", `type == 'XCUIElementTypeButton' AND label == '${v}'`],
+        ["-ios predicate string", `type == 'XCUIElementTypeButton' AND name == '${v}'`],
+        ["accessibility id", text],
+        ["name", text],
+        ["-ios predicate string", `label == '${v}'`],
+        ["-ios predicate string", `name == '${v}'`],
+        ["-ios predicate string", `label CONTAINS '${v}'`],
+    ];
+}
+function humanizeDateTime(date) {
+    return date.toLocaleString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+}
+function fail(error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+}
+function readPngWidth(buffer) {
+    if (buffer.length < 24)
+        return 0;
+    try {
+        return buffer.readUInt32BE(16);
+    }
+    catch {
+        return 0;
+    }
+}

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

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