@autifyhq/aximo-cli 0.10.1 → 0.11.0

package/dist/mobile-control/android-recovery.js

@@ -0,0 +1,19 @@
+import { execBinary } from "./exec.js";
+// Helper APKs left by an older driver version can wedge instrumentation: the
+// packages are installed but Android refuses to register the test runner, so
+// every session fails with one of these until the stale APKs are removed.
+const WEDGED_INSTRUMENTATION_PATTERN = /instrumentation process cannot be initialized|Unable to find instrumentation info|INSTRUMENTATION_FAILED/i;
+export function isWedgedInstrumentationError(err) {
+    return err instanceof Error && WEDGED_INSTRUMENTATION_PATTERN.test(err.message);
+}
+export const APPIUM_HELPER_PACKAGES = [
+    "io.appium.uiautomator2.server.test",
+    "io.appium.uiautomator2.server",
+    "io.appium.settings",
+];
+/** Remove stale Appium helper APKs (best-effort) so the driver reinstalls fresh ones. */
+export async function uninstallAppiumHelpers(serial, exec = execBinary) {
+    for (const pkg of APPIUM_HELPER_PACKAGES) {
+        await exec("adb", ["-s", serial, "uninstall", pkg]).catch(() => { });
+    }
+}

package/dist/mobile-control/android-recovery.test.d.ts

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

package/dist/mobile-control/android-recovery.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { APPIUM_HELPER_PACKAGES, isWedgedInstrumentationError, uninstallAppiumHelpers, } from "./android-recovery.js";
+describe("isWedgedInstrumentationError", () => {
+    it("matches the driver's wedged-instrumentation signatures", () => {
+        expect(isWedgedInstrumentationError(new Error("WebDriver POST /session failed: unknown error: The instrumentation process cannot be initialized."))).toBe(true);
+        expect(isWedgedInstrumentationError(new Error("Unable to find instrumentation info for: ComponentInfo{io.appium.uiautomator2.server.test/androidx.test.runner.AndroidJUnitRunner}"))).toBe(true);
+        expect(isWedgedInstrumentationError(new Error("INSTRUMENTATION_FAILED: io.appium.uiautomator2.server.test/..."))).toBe(true);
+    });
+    it("does not match unrelated session errors or non-errors", () => {
+        expect(isWedgedInstrumentationError(new Error("Could not find a connected Android device"))).toBe(false);
+        expect(isWedgedInstrumentationError("instrumentation process cannot be initialized")).toBe(false);
+    });
+});
+describe("uninstallAppiumHelpers", () => {
+    it("uninstalls all helper packages for the given serial", async () => {
+        const calls = [];
+        const exec = async (_file, args) => {
+            calls.push(args);
+            return { stdout: Buffer.from("Success"), stderr: "" };
+        };
+        await uninstallAppiumHelpers("serial-1", exec);
+        expect(calls).toEqual(APPIUM_HELPER_PACKAGES.map((pkg) => ["-s", "serial-1", "uninstall", pkg]));
+    });
+    it("keeps going when an uninstall fails (package not installed)", async () => {
+        const calls = [];
+        const exec = async (_file, args) => {
+            calls.push(args);
+            throw new Error("Failure [DELETE_FAILED_INTERNAL_ERROR]");
+        };
+        await uninstallAppiumHelpers("serial-1", exec);
+        expect(calls).toHaveLength(APPIUM_HELPER_PACKAGES.length);
+    });
+});

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

@@ -1,4 +1,5 @@
 import type { ActionResult, MobileController } from "./controller.js";
+import type { ExecFn } from "./exec.js";
 import { type IosSigningConfig } from "./ios-signing.js";
 import { type WebDriverTransport } from "./webdriver.js";
 export interface AppiumControllerOptions {
@@ -19,6 +20,8 @@ export interface AppiumControllerOptions {
      */
     mjpegServerPort?: number | (() => Promise<number>);
     transport?: WebDriverTransport;
+    /** adb runner override for tests (used by the wedged-instrumentation repair). */
+    exec?: ExecFn;
 }
 export declare class AppiumController implements MobileController {
     private readonly session;
@@ -27,6 +30,7 @@ export declare class AppiumController implements MobileController {
     private readonly iosSigning;
     private readonly wdaLocalPort;
     private readonly mjpegServerPort;
+    private readonly exec;
     private resolvedWdaPort;
     private resolvedMjpegPort;
     private sessionReady;

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

@@ -1,3 +1,4 @@
+import { isWedgedInstrumentationError, uninstallAppiumHelpers } from "./android-recovery.js";
 import { enrichIosSessionError } from "./ios-session-error.js";
 import { iosSigningCapabilities } from "./ios-signing.js";
 import { fetchTransport, WebDriverSession } from "./webdriver.js";
@@ -38,6 +39,7 @@ export class AppiumController {
     iosSigning;
     wdaLocalPort;
     mjpegServerPort;
+    exec;
     resolvedWdaPort;
     resolvedMjpegPort;
     sessionReady = null;
@@ -48,6 +50,7 @@ export class AppiumController {
         this.iosSigning = opts.iosSigning;
         this.wdaLocalPort = opts.wdaLocalPort;
         this.mjpegServerPort = opts.mjpegServerPort;
+        this.exec = opts.exec;
         const transport = opts.transport ?? fetchTransport(opts.endpoint);
         this.session = new WebDriverSession(transport);
     }
@@ -90,7 +93,18 @@ export class AppiumController {
                     typeof this.mjpegServerPort === "function"
                         ? await this.mjpegServerPort()
                         : this.mjpegServerPort;
-                await this.session.createSession(this.capabilities());
+                try {
+                    await this.session.createSession(this.capabilities());
+                }
+                catch (err) {
+                    // Stale helper APKs from an older driver wedge instrumentation until
+                    // they are removed; wipe them and retry once so the driver reinstalls.
+                    if (this.platform !== "android" || !isWedgedInstrumentationError(err))
+                        throw err;
+                    console.error("Stale Appium helper apps detected on the phone — removing them and retrying once.");
+                    await uninstallAppiumHelpers(this.target, this.exec);
+                    await this.session.createSession(this.capabilities());
+                }
                 await this.applyMjpegSettings();
             })().catch(async (err) => {
                 this.resetSession();

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

@@ -95,6 +95,84 @@ function lastPointerActions(calls) {
     const groups = body["actions"];
     return groups[0]?.actions ?? [];
 }
+describe("AppiumController wedged-instrumentation recovery", () => {
+    function wedgedTransport(failures) {
+        const calls = [];
+        const transport = {
+            async request(method, path, body) {
+                calls.push({ method, path, body });
+                if (method === "POST" && path === "/session") {
+                    const failure = failures.shift();
+                    if (failure)
+                        throw new Error(failure);
+                    return { sessionId: "sess-1" };
+                }
+                if (path.endsWith("/screenshot"))
+                    return pngWithWidth(4);
+                return {};
+            },
+        };
+        return { transport, calls };
+    }
+    const WEDGED = "WebDriver POST /session failed: The instrumentation process cannot be initialized.";
+    it("uninstalls the helper APKs and retries once when instrumentation is wedged", async () => {
+        const adbCalls = [];
+        const exec = async (_file, args) => {
+            adbCalls.push(args);
+            return { stdout: Buffer.from(""), stderr: "" };
+        };
+        const { transport, calls } = wedgedTransport([WEDGED]);
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            transport,
+            exec,
+        });
+        await controller.screenshot();
+        expect(calls.filter((c) => c.path === "/session" && c.method === "POST")).toHaveLength(2);
+        expect(adbCalls.map((a) => a.at(-1))).toEqual([
+            "io.appium.uiautomator2.server.test",
+            "io.appium.uiautomator2.server",
+            "io.appium.settings",
+        ]);
+        expect(adbCalls.every((a) => a[0] === "-s" && a[1] === "udid-1")).toBe(true);
+    });
+    it("does not attempt recovery for unrelated session errors", async () => {
+        const adbCalls = [];
+        const exec = async (_file, args) => {
+            adbCalls.push(args);
+            return { stdout: Buffer.from(""), stderr: "" };
+        };
+        const { transport } = wedgedTransport(["Could not find a connected Android device"]);
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            transport,
+            exec,
+        });
+        await expect(controller.screenshot()).rejects.toThrow("connected Android device");
+        expect(adbCalls).toHaveLength(0);
+    });
+    it("does not attempt adb recovery on iOS", async () => {
+        const adbCalls = [];
+        const exec = async (_file, args) => {
+            adbCalls.push(args);
+            return { stdout: Buffer.from(""), stderr: "" };
+        };
+        const { transport } = wedgedTransport([WEDGED]);
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "ios",
+            target: "udid-1",
+            transport,
+            exec,
+        });
+        await expect(controller.screenshot()).rejects.toThrow();
+        expect(adbCalls).toHaveLength(0);
+    });
+});
 describe("AppiumController session capabilities", () => {
     it("sends Android UiAutomator2 caps", async () => {
         const { controller, calls } = makeController("android");

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

@@ -1,6 +1,22 @@
 const APPIUM = "appium";
 export async function importAppium() {
-    // Appium 3 is CJS, so its `main` is under `.default` when imported from ESM.
-    const mod = (await import(APPIUM));
-    return mod.default ?? mod;
+    try {
+        // Appium 3 is CJS, so its `main` is under `.default` when imported from ESM.
+        const mod = (await import(APPIUM));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        // appium is left out of the single-file build — it pulls in native code the
+        // executable cannot carry — but `aximo mobile` still appears in --help.
+        //
+        // Both codes are needed: a CJS require reports MODULE_NOT_FOUND, while the
+        // dynamic ESM import used here reports ERR_MODULE_NOT_FOUND. The raw message
+        // also names the bundle's build-time path, which means nothing to a customer.
+        const code = err?.code;
+        if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error("Mobile commands are unavailable in the single-file aximo build. " +
+                "Install the CLI from npm to use them: npm i -g @autifyhq/aximo-cli");
+        }
+        throw err;
+    }
 }

package/dist/types.d.ts

@@ -109,6 +109,55 @@ export interface PlanRun {
     status?: string | undefined;
     [key: string]: unknown;
 }
+export interface PlanListItem {
+    id: string;
+    projectId: string;
+    title: string;
+    description: string | null;
+    apiEnabled: boolean;
+    caseCount: number;
+    hasMobileCases: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: {
+        id: string;
+        name: string | null;
+        email: string;
+    } | null;
+}
+export interface PlanDetail {
+    id: string;
+    projectId: string;
+    title: string;
+    description: string | null;
+    apiEnabled: boolean;
+    executionMode: ExecutionMode;
+    stopOnFailure: boolean;
+    variables: {
+        name: string;
+        value: string;
+        isSecret: boolean;
+    }[];
+    caseCount: number;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: {
+        id: string;
+        name: string | null;
+        email: string;
+    } | null;
+    project: {
+        id: string;
+        name: string;
+    } | null;
+    cases: {
+        id: string;
+        order: number;
+        type: string;
+        title: string | null;
+        lastStatus: string | null;
+    }[];
+}
 export interface PlanRunSummary {
     id: string;
     status: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autifyhq/aximo-cli",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Autify Aximo Command Line Interface (CLI)",
   "keywords": [
     "autify",
@@ -52,11 +52,13 @@
     "@types/node": "^25.6.0",
     "@types/ws": "^8.18.0",
     "@vitest/coverage-v8": "4.1.4",
+    "esbuild": "0.27.7",
     "husky": "9.1.7",
     "msw": "2.13.2",
     "nano-staged": "1.0.2",
     "oxfmt": "0.45.0",
     "oxlint": "1.60.0",
+    "postject": "1.0.0-alpha.6",
     "secretlint": "11.7.1",
     "tsx": "4.21.0",
     "typescript": "6.0.2",
@@ -67,6 +69,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "build:sea": "node scripts/build-sea.mjs",
     "cli": "tsx src/cli.ts",
     "format": "oxfmt --write .",
     "format:check": "oxfmt --check .",