@autifyhq/aximo-cli 0.7.0 → 0.8.0

package/README.md

@@ -34,6 +34,8 @@ aximo session get SESSION_ID
 
 Get your API key from **Settings → API Keys** in the [Aximo dashboard](https://aximo.autify.com).
 
+Want to run tests on **your own hardware** instead of the cloud? See [Device (BYOD)](#device-byod--bring-your-own-device) to register this desktop (Windows/macOS/Linux), or [Mobile](#mobile-local-android-phone-or-iphone) to drive a USB-connected Android phone or iPhone — each section starts with the exact prerequisites for a fresh machine.
+
 ## Configuration
 
 Each credential resolves independently: the value in `$AXIMO_HOME/config.json` (written by `aximo configure`) wins, then the environment variable, then the default.
@@ -208,9 +210,9 @@ Terminology note: **`aximo device list` returns mobile devices** from Device Far
 
 ### Prerequisites
 
-- **Node.js 20+**, plus `aximo-cli` installed globally (see [Install](#install)).
+- **Node.js 20.18+**, plus `aximo-cli` installed globally (see [Install](#install)).
 - **An Aximo API key**, configured via `aximo configure` or env vars.
-- **Active desktop session** — the agent uses `pyautogui` for screenshots and input, so the screen must be unlocked and awake while tests run.
+- **Active desktop session** — the agent uses `pyautogui` for screenshots and input, so the screen must be unlocked and awake while tests run. On **macOS**, grant the terminal **Accessibility** and **Screen Recording** permissions (System Settings → Privacy & Security) — without them actions silently do nothing.
 - **Outbound WebSocket to port 443** — most corporate firewalls allow this; if yours doesn't, see [Troubleshooting](#byod-troubleshooting).
 
 > Python is **not** a prerequisite. On first `connect` (or via `device setup`), the CLI downloads a self-contained CPython build into `$AXIMO_HOME/python/` (~35 MB download, ~130 MB installed) and installs the required packages. Your system Python is untouched.
@@ -411,7 +413,7 @@ Terminology note: **`aximo mobile list`** shows phones plugged into _this_ machi
 
 ### Prerequisites
 
-- **Node.js 20+**, plus `aximo-cli` installed globally (see [Install](#install)).
+- **Node.js 20.18+**, plus `aximo-cli` installed globally (see [Install](#install)).
 - **An Aximo API key**, configured via `aximo configure` or env vars.
 - **A USB-connected phone**:
   - **Android** — **USB debugging** enabled and authorized — see [Enable USB debugging on the phone](#enable-usb-debugging-on-the-phone).
@@ -429,12 +431,13 @@ You only need **`adb`** and the **Android SDK** on the machine running `aximo mo
 **macOS**
 
 ```bash
-# Option A — standalone platform-tools (just adb):
-brew install --cask android-platform-tools
+# Option A — standalone SDK Platform-Tools (no Android Studio): download the zip from
+# https://developer.android.com/tools/releases/platform-tools and unzip it so adb ends up at
+# ~/Library/Android/sdk/platform-tools/adb  (the driver needs this SDK layout, not just adb on PATH)
 # Option B — full Android Studio (also installs the SDK):
 brew install --cask android-studio
 
-# Point ANDROID_HOME at the SDK (Android Studio's default location shown):
+# Point ANDROID_HOME at the SDK (both options above use this location):
 echo 'export ANDROID_HOME="$HOME/Library/Android/sdk"' >> ~/.zshrc
 echo 'export PATH="$PATH:$ANDROID_HOME/platform-tools"'  >> ~/.zshrc
 source ~/.zshrc
@@ -496,7 +499,7 @@ Run `aximo mobile doctor --platform ios` to see what was discovered (identity, t
 
 > **On-device steps you can't skip** (Apple requires them once per phone): enable **Developer Mode** (Settings → Privacy & Security → Developer Mode; the phone restarts), tap **Trust This Computer**, and — after the first install of an app signed by your team — **trust the developer certificate** (Settings → General → VPN & Device Management → your "Apple Development" profile → Trust; the phone needs internet). On **free/personal teams** profiles expire every ~7 days; the CLI re-mints them automatically, but a re-mint **resets the certificate trust**, so expect that trust tap to recur weekly. Free teams are also capped at 10 App IDs per week.
 >
-> On **iOS 17+**, `aximo mobile connect` also starts a small **device tunnel that needs admin rights** — it prompts once for your macOS password / Touch ID (reused on later runs, so at most once per boot). Devices below iOS 17 skip the tunnel entirely. If anything mentions "iOS X is not installed", run `xcodebuild -downloadPlatform iOS` (only the classic build flow needs it).
+> On **iOS 17+**, `aximo mobile connect` also starts a small **device tunnel that needs admin rights** — it prompts once for your macOS password / Touch ID (reused on later runs, so at most once per boot). The tunnel deliberately keeps running after `connect` exits; stop it anytime with `sudo pkill -f tunnel-creation`. Devices below iOS 17 skip the tunnel entirely, and Android never uses it. If anything mentions "iOS X is not installed", run `xcodebuild -downloadPlatform iOS` (only the classic build flow needs it).
 
 ### Enable USB debugging on the phone
 

package/dist/commands/mobile/connect-core.js

@@ -5,7 +5,7 @@ import { installUploadedApp } from "../../mobile-control/app-install.js";
 import { pickFreePort, startAppiumServer } from "../../mobile-control/appium-server.js";
 import { withBundleIdTranslation } from "../../mobile-control/bundle-id-map.js";
 import { getIosDeviceInfo, iosMajorVersion } from "../../mobile-control/ios-devicectl.js";
-import { ensureIosTunnel } from "../../mobile-control/ios-tunnel.js";
+import { ensureIosTunnel, TUNNEL_STOP_COMMAND } from "../../mobile-control/ios-tunnel.js";
 import { resolveIosSigning, resolveIosSigningAuto, } from "../../mobile-control/ios-signing.js";
 import { resolveWdaCaching } from "../../mobile-control/ios-wda-cache.js";
 import { resolvePreinstalledWdaStrategy } from "../../mobile-control/ios-wda-preinstall.js";
@@ -28,9 +28,8 @@ export function resolveDeviceConfig(deviceId) {
         return formatError("validation_error", 'No registered devices. Register one first: aximo mobile register --name "My Pixel" --platform android', false);
     }
     if (all.length > 1) {
-        return formatError("validation_error", `Multiple devices registered; pass --device-id. Registered: ${all
-            .map((c) => `${c.name} (${c.deviceId})`)
-            .join(", ")}`, false);
+        const lines = all.map((c) => `  - ${c.name} (${c.platform}) — device-id: ${c.deviceId}`);
+        return formatError("validation_error", `Multiple devices are registered on this machine; pass --device-id to pick one:\n${lines.join("\n")}`, false, `Re-run with --device-id, e.g. --device-id ${all[0]?.deviceId}`);
     }
     const only = all[0];
     if (!only) {
@@ -90,6 +89,7 @@ async function preflightIosDevice(udid) {
 export async function connectWithConfig(config) {
     await assertPrerequisites(config.platform);
     let iosMajor = null;
+    let tunnelRunning = false;
     if (config.platform === "ios") {
         iosMajor = await preflightIosDevice(config.target);
         // Physical iPhones on iOS 17+ need the RemoteXPC tunnel before XCUITest can
@@ -100,6 +100,7 @@ export async function connectWithConfig(config) {
         }
         else {
             const tunnel = await ensureIosTunnel();
+            tunnelRunning = tunnel.started || tunnel.reused;
             if (tunnel.reused)
                 console.error("Reusing the running iOS device tunnel.");
         }
@@ -182,5 +183,9 @@ export async function connectWithConfig(config) {
     finally {
         await controller.close();
         await server.stop();
+        if (tunnelRunning) {
+            console.error("The iOS device tunnel is still running in the background (admin-started; the next " +
+                `connect won't prompt again). Stop it anytime with: ${TUNNEL_STOP_COMMAND}`);
+        }
     }
 }

package/dist/commands/mobile/connect.js

@@ -1,7 +1,8 @@
 import { defineCommand } from "citty";
 import { mobileErrorHint } from "../../mobile-control/mobile-errors.js";
-import { formatError, printResult } from "../../output.js";
+import { formatError } from "../../output.js";
 import { connectWithConfig, resolveDeviceConfig } from "./connect-core.js";
+import { printMobileResult } from "./output.js";
 const IOS_PHYSICAL_WARNING = "Driving a physical iPhone goes through Appium's XCUITest driver, which builds and " +
     "installs a WebDriverAgent runner on the device. The device must have Developer Mode " +
     "enabled (Settings → Privacy & Security) and be trusted, and WDA needs an Apple Developer " +
@@ -20,7 +21,7 @@ export default defineCommand({
     async run({ args }) {
         const resolved = resolveDeviceConfig(args["device-id"]);
         if (!resolved.ok) {
-            printResult(resolved);
+            printMobileResult(resolved);
             return;
         }
         const warning = iosPhysicalWarning(resolved.config);
@@ -31,7 +32,7 @@ export default defineCommand({
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            printResult(formatError("api_error", message, true, mobileErrorHint(message, resolved.config.platform)));
+            printMobileResult(formatError("api_error", message, true, mobileErrorHint(message, resolved.config.platform)));
         }
     },
 });

package/dist/commands/mobile/connect.test.js

@@ -61,7 +61,7 @@ describe("resolveDeviceConfig", () => {
         if (result.ok)
             expect(result.config.deviceId).toBe("only-1");
     });
-    it("requires --device-id when multiple are registered", () => {
+    it("requires --device-id when multiple are registered, listing each candidate", () => {
         for (const id of ["a", "b"]) {
             writeMobileDeviceConfig({
                 deviceId: id,
@@ -73,6 +73,12 @@ describe("resolveDeviceConfig", () => {
         }
         const ambiguous = resolveDeviceConfig(undefined);
         expect(ambiguous.ok).toBe(false);
+        if (!ambiguous.ok) {
+            expect(ambiguous.error.message).toContain("pass --device-id");
+            expect(ambiguous.error.message).toContain("device-id: a");
+            expect(ambiguous.error.message).toContain("device-id: b");
+            expect(ambiguous.error.hint).toContain("--device-id");
+        }
         const picked = resolveDeviceConfig("b");
         expect(picked.ok).toBe(true);
         if (picked.ok)

package/dist/commands/mobile/doctor.d.ts

@@ -22,6 +22,7 @@ export interface RunMobileDoctorOptions {
     isTunnelHealthy?: (port: number) => Promise<boolean>;
 }
 export declare function runMobileDoctor(options?: RunMobileDoctorOptions): Promise<Envelope<MobileDoctorReport>>;
+export declare function renderDoctorReport(data: MobileDoctorReport): string;
 declare const _default: import("citty").CommandDef<{
     readonly platform: {
         readonly type: "string";

package/dist/commands/mobile/doctor.js

@@ -3,7 +3,8 @@ import { existsSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { platform } from "node:os";
 import { join } from "node:path";
-import { formatSuccess, printResult } from "../../output.js";
+import { formatSuccess } from "../../output.js";
+import { printMobileResult } from "./output.js";
 import { importAppium } from "../../mobile-control/appium-import.js";
 import { getAppiumHome, resolveAndroidSdk } from "../../mobile-control/appium-server.js";
 import { resolveIosSigningAuto } from "../../mobile-control/ios-signing.js";
@@ -171,6 +172,21 @@ export async function runMobileDoctor(options = {}) {
         summary[c.status]++;
     return formatSuccess({ checks, summary });
 }
+const STATUS_MARK = {
+    pass: "✓",
+    warn: "!",
+    fail: "✗",
+    info: "i",
+};
+export function renderDoctorReport(data) {
+    const lines = data.checks.map((c) => {
+        const line = `${STATUS_MARK[c.status]} ${c.name}: ${c.message}`;
+        return c.hint ? `${line}\n    ${c.hint}` : line;
+    });
+    const s = data.summary;
+    lines.push(`Summary: ${s.pass} pass, ${s.warn} warn, ${s.fail} fail, ${s.info} info`);
+    return lines.join("\n");
+}
 export default defineCommand({
     meta: {
         name: "doctor",
@@ -184,7 +200,7 @@ export default defineCommand({
         if (args.platform === "ios" || args.platform === "android")
             options.platform = args.platform;
         const result = await runMobileDoctor(options);
-        printResult(result);
+        printMobileResult(result, { render: renderDoctorReport });
         if (result.ok && result.data.summary.fail > 0) {
             process.exitCode = 1;
         }

package/dist/commands/mobile/doctor.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { checkIosTunnel } from "./doctor.js";
+import { checkIosTunnel, renderDoctorReport } from "./doctor.js";
 describe("checkIosTunnel", () => {
     it("passes when the RemoteXPC tunnel is reachable", async () => {
         const check = await checkIosTunnel(async () => true);
@@ -12,3 +12,17 @@ describe("checkIosTunnel", () => {
         expect(check.hint).toContain("aximo mobile connect");
     });
 });
+describe("renderDoctorReport", () => {
+    it("renders one line per check with status marks, indented hints, and a summary", () => {
+        const text = renderDoctorReport({
+            checks: [
+                { name: "appium", status: "pass", message: "bundled Appium found" },
+                { name: "adb", status: "fail", message: "adb not found", hint: "install platform-tools" },
+            ],
+            summary: { pass: 1, warn: 0, fail: 1, info: 0 },
+        });
+        expect(text).toContain("✓ appium: bundled Appium found");
+        expect(text).toContain("✗ adb: adb not found\n    install platform-tools");
+        expect(text).toContain("Summary: 1 pass, 0 warn, 1 fail, 0 info");
+    });
+});

package/dist/commands/mobile/install.d.ts

@@ -28,6 +28,7 @@ export interface MobileInstallOptions {
  * signature doesn't already cover it (disable with AXIMO_IOS_NO_RESIGN).
  */
 export declare function runMobileInstall(options: MobileInstallOptions, exec?: ExecFn, ensureInstallable?: typeof ensureInstallableIpa, installIos?: typeof installIosApp): Promise<Envelope<MobileInstallResult>>;
+export declare function renderInstallResult(data: MobileInstallResult): string;
 declare const _default: import("citty").CommandDef<{
     readonly app: {
         readonly type: "string";

package/dist/commands/mobile/install.js

@@ -7,7 +7,8 @@ import { execBinary } from "../../mobile-control/exec.js";
 import { ensureInstallableIpa } from "../../mobile-control/ios-auto-resign.js";
 import { installIosApp } from "../../mobile-control/ios-devicectl.js";
 import { mobileErrorHint } from "../../mobile-control/mobile-errors.js";
-import { formatError, formatSuccess, printResult } from "../../output.js";
+import { formatError, formatSuccess } from "../../output.js";
+import { printMobileResult } from "./output.js";
 import { parsePlatformArg } from "./register-core.js";
 function inferPlatform(appPath) {
     const ext = extname(appPath).toLowerCase();
@@ -85,6 +86,16 @@ export async function runMobileInstall(options, exec = execBinary, ensureInstall
         return formatError("api_error", message, false, mobileErrorHint(message, platform));
     }
 }
+export function renderInstallResult(data) {
+    const target = data.serial ?? data.udid ?? "device";
+    const lines = [`Installed ${data.app} on ${data.platform} device ${target}.`];
+    if (data.resigned) {
+        lines.push(`Re-signed for this device: ${data.originalBundleId} installed as ${data.installedBundleId}.`);
+    }
+    if (data.output)
+        lines.push(data.output);
+    return lines.join("\n");
+}
 export default defineCommand({
     meta: {
         name: "install",
@@ -97,11 +108,11 @@ export default defineCommand({
         udid: { type: "string", description: "iOS device udid (defaults to the connected one)" },
     },
     async run({ args }) {
-        printResult(await runMobileInstall({
+        printMobileResult(await runMobileInstall({
             app: args.app,
             platform: args.platform,
             serial: args.serial,
             udid: args.udid,
-        }));
+        }), { render: renderInstallResult });
     },
 });

package/dist/commands/mobile/list.d.ts

@@ -8,5 +8,6 @@ export interface MobileListResult {
     warnings?: string[];
 }
 export declare function runMobileList(exec?: ExecFn): Promise<Envelope<MobileListResult>>;
+export declare function renderMobileList(data: MobileListResult): string;
 declare const _default: import("citty").CommandDef<{}>;
 export default _default;

package/dist/commands/mobile/list.js

@@ -1,5 +1,6 @@
 import { defineCommand } from "citty";
-import { formatSuccess, printResult } from "../../output.js";
+import { formatSuccess } from "../../output.js";
+import { printMobileResult } from "./output.js";
 import { listAndroidDevices, listIosPhysicalDevices, } from "../../mobile-control/devices.js";
 export async function runMobileList(exec) {
     const warnings = [];
@@ -24,13 +25,32 @@ export async function runMobileList(exec) {
         ...(warnings.length > 0 ? { warnings } : {}),
     });
 }
+export function renderMobileList(data) {
+    const lines = ["Android phones (adb):"];
+    if (data.androidDevices.length === 0)
+        lines.push("  (none connected)");
+    for (const d of data.androidDevices) {
+        const label = d.model ? `${d.model} — ` : "";
+        lines.push(`  - ${label}serial: ${d.serial} (${d.state})`);
+    }
+    lines.push("iOS phones (devicectl):");
+    if (data.iosDevices.length === 0)
+        lines.push("  (none connected)");
+    for (const d of data.iosDevices) {
+        lines.push(`  - ${d.name} — udid: ${d.udid}${d.state ? ` (${d.state})` : ""}`);
+    }
+    for (const w of data.warnings ?? [])
+        lines.push(`Warning: ${w}`);
+    lines.push('Next: aximo mobile register --name "My Phone" --platform android|ios');
+    return lines.join("\n");
+}
 export default defineCommand({
     meta: {
         name: "list",
-        description: "List physically-connected phones (Android via adb, iOS via idb)",
+        description: "List physically-connected phones (Android via adb, iOS via devicectl)",
     },
     args: {},
     async run() {
-        printResult(await runMobileList());
+        printMobileResult(await runMobileList(), { render: renderMobileList });
     },
 });

package/dist/commands/mobile/list.test.d.ts

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

package/dist/commands/mobile/list.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { renderMobileList } from "./list.js";
+describe("renderMobileList", () => {
+    it("lists devices per platform with serial/udid and state", () => {
+        const text = renderMobileList({
+            androidDevices: [{ serial: "1A2B3C", state: "device", model: "Pixel_7" }],
+            iosDevices: [{ udid: "00008120-XYZ", name: "My iPhone", state: "Booted" }],
+        });
+        expect(text).toContain("Android phones (adb):");
+        expect(text).toContain("  - Pixel_7 — serial: 1A2B3C (device)");
+        expect(text).toContain("iOS phones (devicectl):");
+        expect(text).toContain("  - My iPhone — udid: 00008120-XYZ (Booted)");
+        expect(text).not.toContain("(none connected)");
+    });
+    it("marks empty platforms and surfaces discovery warnings", () => {
+        const text = renderMobileList({
+            androidDevices: [],
+            iosDevices: [],
+            warnings: ["ios (idb): idb not found"],
+        });
+        expect(text).toContain("(none connected)");
+        expect(text).toContain("Warning: ios (idb): idb not found");
+    });
+});

package/dist/commands/mobile/output.d.ts

@@ -0,0 +1,13 @@
+import type { Envelope } from "../../types.js";
+export interface PrintMobileResultOptions<T> {
+    /** Human rendering of the success payload; falls back to pretty-printed data. */
+    render?: (data: T) => string;
+    /** Defaults to stdout being a TTY; tests override. */
+    interactive?: boolean;
+}
+/**
+ * Mobile commands are usually run by a person at a terminal, where the raw JSON
+ * envelope is hard to read. Print human-readable text when stdout is a TTY, and
+ * keep the JSON envelope when piped — scripts and agents parse it.
+ */
+export declare function printMobileResult<T>(result: Envelope<T>, options?: PrintMobileResultOptions<T>): void;

package/dist/commands/mobile/output.js

@@ -0,0 +1,21 @@
+import { printResult } from "../../output.js";
+/**
+ * Mobile commands are usually run by a person at a terminal, where the raw JSON
+ * envelope is hard to read. Print human-readable text when stdout is a TTY, and
+ * keep the JSON envelope when piped — scripts and agents parse it.
+ */
+export function printMobileResult(result, options = {}) {
+    const interactive = options.interactive ?? process.stdout.isTTY === true;
+    if (!interactive) {
+        printResult(result);
+        return;
+    }
+    if (!result.ok) {
+        console.error(`Error: ${result.error.message}`);
+        if (result.error.hint)
+            console.error(`Hint: ${result.error.hint}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(options.render ? options.render(result.data) : JSON.stringify(result.data, null, 2));
+}

package/dist/commands/mobile/output.test.d.ts

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

package/dist/commands/mobile/output.test.js

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { formatError, formatSuccess } from "../../output.js";
+import { printMobileResult } from "./output.js";
+afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+});
+describe("printMobileResult", () => {
+    it("prints the JSON envelope when not interactive", () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        printMobileResult(formatSuccess({ a: 1 }), { interactive: false });
+        expect(log).toHaveBeenCalledOnce();
+        expect(JSON.parse(log.mock.calls[0]?.[0])).toEqual({ ok: true, data: { a: 1 } });
+    });
+    it("prints the JSON envelope for errors when not interactive and sets the exit code", () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        printMobileResult(formatError("validation_error", "boom", false), { interactive: false });
+        expect(JSON.parse(log.mock.calls[0]?.[0])).toMatchObject({
+            ok: false,
+            error: { message: "boom" },
+        });
+        expect(process.exitCode).toBe(1);
+    });
+    it("prints a human-readable error with hint to stderr when interactive", () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        const error = vi.spyOn(console, "error").mockImplementation(() => { });
+        printMobileResult(formatError("validation_error", "boom", false, "try this"), {
+            interactive: true,
+        });
+        expect(log).not.toHaveBeenCalled();
+        expect(error).toHaveBeenCalledWith("Error: boom");
+        expect(error).toHaveBeenCalledWith("Hint: try this");
+        expect(process.exitCode).toBe(1);
+    });
+    it("omits the hint line when the error has none", () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => { });
+        printMobileResult(formatError("api_error", "boom", true), { interactive: true });
+        expect(error).toHaveBeenCalledTimes(1);
+    });
+    it("renders success data with the provided renderer when interactive", () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        printMobileResult(formatSuccess({ n: 2 }), {
+            interactive: true,
+            render: (d) => `n is ${d.n}`,
+        });
+        expect(log).toHaveBeenCalledWith("n is 2");
+        expect(process.exitCode).toBeUndefined();
+    });
+    it("falls back to pretty-printed data without a renderer when interactive", () => {
+        const log = vi.spyOn(console, "log").mockImplementation(() => { });
+        printMobileResult(formatSuccess({ n: 2 }), { interactive: true });
+        expect(JSON.parse(log.mock.calls[0]?.[0])).toEqual({ n: 2 });
+    });
+});

package/dist/commands/mobile/register.d.ts

@@ -10,6 +10,7 @@ export interface MobileRegisterCmdOptions {
     os?: string | undefined;
 }
 export declare function runMobileRegister(options: MobileRegisterCmdOptions, deps?: ClientDeps, exec?: ExecFn): Promise<Envelope<MobileRegisterResult>>;
+export declare function renderRegisterResult(data: MobileRegisterResult): string;
 declare const _default: import("citty").CommandDef<{
     readonly name: {
         readonly type: "string";

package/dist/commands/mobile/register.js

@@ -1,7 +1,8 @@
 import { defineCommand } from "citty";
 import {} from "../../client.js";
-import { formatError, printResult } from "../../output.js";
+import { formatError } from "../../output.js";
 import { resolveAndroidSerial, resolveIosUdid } from "../../mobile-control/devices.js";
+import { printMobileResult } from "./output.js";
 import { parsePlatformArg, registerMobileDevice, } from "./register-core.js";
 export async function runMobileRegister(options, deps, exec) {
     const platform = parsePlatformArg(options.platform);
@@ -29,6 +30,13 @@ export async function runMobileRegister(options, deps, exec) {
         ...(options.os ? { os: options.os } : {}),
     }, deps);
 }
+export function renderRegisterResult(data) {
+    return [
+        `Registered "${data.name}" (${data.platform}, target ${data.target}) as device ${data.deviceId}.`,
+        `Config: ${data.configPath}`,
+        "Next: aximo mobile connect",
+    ].join("\n");
+}
 export default defineCommand({
     meta: {
         name: "register",
@@ -46,12 +54,12 @@ export default defineCommand({
         os: { type: "string", description: "Optional OS version label" },
     },
     async run({ args }) {
-        printResult(await runMobileRegister({
+        printMobileResult(await runMobileRegister({
             name: args.name,
             platform: args.platform,
             serial: args.serial,
             udid: args.udid,
             os: args.os,
-        }));
+        }), { render: renderRegisterResult });
     },
 });

package/dist/commands/mobile/setup.d.ts

@@ -18,6 +18,7 @@ export interface RunMobileSetupOptions {
     }) => Promise<Envelope<MobileDoctorReport>>;
 }
 export declare function runMobileSetup(options?: RunMobileSetupOptions): Promise<Envelope<SetupResult>>;
+export declare function renderSetupResult(data: SetupResult): string;
 declare const _default: import("citty").CommandDef<{
     readonly platform: {
         readonly type: "string";

package/dist/commands/mobile/setup.js

@@ -3,7 +3,8 @@ import { execFile } from "node:child_process";
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import { formatError, formatSuccess, printResult } from "../../output.js";
+import { formatError, formatSuccess } from "../../output.js";
+import { printMobileResult } from "./output.js";
 import { getAppiumHome } from "../../mobile-control/appium-server.js";
 import { runMobileDoctor } from "./doctor.js";
 const DRIVER_PACKAGE = {
@@ -82,6 +83,10 @@ export async function runMobileSetup(options = {}) {
     printNextSteps(report.ok ? report.data.checks : []);
     return formatSuccess({ appiumHome, drivers: results });
 }
+export function renderSetupResult(data) {
+    const lines = data.drivers.map((d) => `  - ${d.driver}: ${d.alreadyInstalled ? "already installed" : "installed"}`);
+    return [`Appium home: ${data.appiumHome}`, ...lines].join("\n");
+}
 export default defineCommand({
     meta: {
         name: "setup",
@@ -95,6 +100,6 @@ export default defineCommand({
         if (args.platform === "ios" || args.platform === "android")
             options.platform = args.platform;
         const result = await runMobileSetup(options);
-        printResult(result);
+        printMobileResult(result, { render: renderSetupResult });
     },
 });

package/dist/commands/mobile/unregister.d.ts

@@ -1,10 +1,14 @@
 import { type ClientDeps } from "../../client.js";
 import type { Envelope } from "../../types.js";
+export interface MobileUnregisterResult {
+    success: boolean;
+    deviceId: string;
+    name: string;
+}
 export declare function runMobileUnregister(options: {
     deviceId?: string;
-}, deps?: ClientDeps): Promise<Envelope<{
-    success: boolean;
-}>>;
+}, deps?: ClientDeps): Promise<Envelope<MobileUnregisterResult>>;
+export declare function renderUnregisterResult(data: MobileUnregisterResult): string;
 declare const _default: import("citty").CommandDef<{
     readonly "device-id": {
         readonly type: "string";

package/dist/commands/mobile/unregister.js

@@ -2,14 +2,15 @@ import { defineCommand } from "citty";
 import { existsSync, unlinkSync } from "node:fs";
 import { request } from "../../client.js";
 import { handleApiError } from "../../errors.js";
-import { formatSuccess, printResult } from "../../output.js";
+import { formatSuccess } from "../../output.js";
 import { resolveDeviceConfig } from "./connect-core.js";
+import { printMobileResult } from "./output.js";
 import { getMobileDeviceConfigPath } from "./paths.js";
 export async function runMobileUnregister(options, deps) {
     const resolved = resolveDeviceConfig(options.deviceId);
     if (!resolved.ok)
         return resolved;
-    const { deviceId } = resolved.config;
+    const { deviceId, name } = resolved.config;
     try {
         await request(`/api/devices/user/${deviceId}`, { method: "DELETE" }, deps ?? {});
     }
@@ -25,7 +26,10 @@ export async function runMobileUnregister(options, deps) {
     if (existsSync(configPath)) {
         unlinkSync(configPath);
     }
-    return formatSuccess({ success: true });
+    return formatSuccess({ success: true, deviceId, name });
+}
+export function renderUnregisterResult(data) {
+    return `Unregistered "${data.name}" (device ${data.deviceId}).`;
 }
 export default defineCommand({
     meta: { name: "unregister", description: "Unregister a local mobile device" },
@@ -37,6 +41,8 @@ export default defineCommand({
     },
     async run({ args }) {
         const deviceId = args["device-id"];
-        printResult(await runMobileUnregister(deviceId ? { deviceId } : {}));
+        printMobileResult(await runMobileUnregister(deviceId ? { deviceId } : {}), {
+            render: renderUnregisterResult,
+        });
     },
 });

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

@@ -2,5 +2,9 @@ export interface ExecResult {
     stdout: Buffer;
     stderr: string;
 }
-export type ExecFn = (file: string, args: string[]) => Promise<ExecResult>;
+export interface ExecOptions {
+    /** Working directory for the child (e.g. to zip relative paths). */
+    cwd?: string;
+}
+export type ExecFn = (file: string, args: string[], opts?: ExecOptions) => Promise<ExecResult>;
 export declare const execBinary: ExecFn;

package/dist/mobile-control/exec.js

@@ -1,7 +1,7 @@
 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) => {
+export const execBinary = (file, args, opts) => new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "buffer", maxBuffer: 64 * 1024 * 1024, ...(opts?.cwd ? { cwd: opts.cwd } : {}) }, (error, stdout, stderr) => {
         const stderrText = stderr.toString("utf-8");
         if (error) {
             const message = stderrText.trim() || error.message;

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

@@ -6,6 +6,8 @@
  * Older iOS and self-managed setups can opt out with AXIMO_IOS_SKIP_TUNNEL.
  */
 export declare const DEFAULT_TUNNEL_REGISTRY_PORT = 42314;
+/** How to stop the elevated tunnel daemon — surfaced whenever we start or leave it running. */
+export declare const TUNNEL_STOP_COMMAND = "sudo pkill -f tunnel-creation";
 /**
  * True when the tunnel registry server answers its HTTP API on `port`. A raw
  * TCP connect is not enough — an unrelated listener on the port would be
@@ -20,8 +22,9 @@ export interface TunnelScriptOptions {
 }
 /**
  * A self-contained shell script that launches the driver's `tunnel-creation` as a
- * detached background daemon. Run as root via the macOS auth prompt; it returns
- * immediately while the tunnel keeps running (health-checked via the registry port).
+ * fully detached daemon (own session, via {@link DAEMONIZE_PERL}). Run as root via
+ * the macOS auth prompt; it returns immediately while the tunnel keeps running
+ * (health-checked via the registry port).
  */
 export declare function buildTunnelScript(opts: TunnelScriptOptions): string;
 /** Prompt for admin rights (password/Touch ID) and run the tunnel script as root. */

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

@@ -13,6 +13,8 @@ import { envFlag } from "./env-flags.js";
  * Older iOS and self-managed setups can opt out with AXIMO_IOS_SKIP_TUNNEL.
  */
 export const DEFAULT_TUNNEL_REGISTRY_PORT = 42314;
+/** How to stop the elevated tunnel daemon — surfaced whenever we start or leave it running. */
+export const TUNNEL_STOP_COMMAND = "sudo pkill -f tunnel-creation";
 /**
  * True when the tunnel registry server answers its HTTP API on `port`. A raw
  * TCP connect is not enough — an unrelated listener on the port would be
@@ -36,17 +38,34 @@ export async function isTunnelHealthy(port = DEFAULT_TUNNEL_REGISTRY_PORT, host
 function shQuote(value) {
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
+// Daemonize via perl (always present on macOS). A plain `nohup … &` does NOT
+// survive `do shell script … with administrator privileges`: the security
+// trampoline tears down its child's process group when the script returns, and
+// nohup only blocks SIGHUP — so the tunnel is killed before it initializes.
+// Double-fork + setsid moves the daemon into its own session and process group,
+// out of the trampoline's reach. $ARGV[0] is the log file; $ARGV[1..] the argv.
+const DAEMONIZE_PERL = [
+    "use POSIX qw(setsid);",
+    "open(STDIN, '<', '/dev/null');",
+    "open(STDOUT, '>', $ARGV[0]) or die $!;",
+    "open(STDERR, '>&', STDOUT);",
+    "exit if fork;", // top process (the trampoline's child) returns immediately
+    "setsid();", // child leads a new session — detached from the trampoline
+    "exit if fork;", // grandchild can never reacquire a controlling terminal
+    "exec(@ARGV[1 .. $#ARGV]) or die $!;",
+].join(" ");
 /**
  * A self-contained shell script that launches the driver's `tunnel-creation` as a
- * detached background daemon. Run as root via the macOS auth prompt; it returns
- * immediately while the tunnel keeps running (health-checked via the registry port).
+ * fully detached daemon (own session, via {@link DAEMONIZE_PERL}). Run as root via
+ * the macOS auth prompt; it returns immediately while the tunnel keeps running
+ * (health-checked via the registry port).
  */
 export function buildTunnelScript(opts) {
     return [
         "#!/bin/sh",
         `export APPIUM_HOME=${shQuote(opts.appiumHome)}`,
         'export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"',
-        `nohup ${shQuote(opts.nodePath)} ${shQuote(opts.appiumBin)} driver run xcuitest tunnel-creation > ${shQuote(opts.logFile)} 2>&1 &`,
+        `exec perl -e ${shQuote(DAEMONIZE_PERL)} ${shQuote(opts.logFile)} ${shQuote(opts.nodePath)} ${shQuote(opts.appiumBin)} driver run xcuitest tunnel-creation`,
         "",
     ].join("\n");
 }
@@ -81,7 +100,7 @@ async function pollHealthy(isHealthy, port, timeoutMs, logFile) {
     }
     throw new Error(`iOS device tunnel did not become ready within ${timeoutMs}ms. ` +
         `Check ${logFile} for the daemon's output. A partially-started daemon may still ` +
-        "be running; stop it before retrying: sudo pkill -f tunnel-creation");
+        `be running; stop it before retrying: ${TUNNEL_STOP_COMMAND}`);
 }
 /**
  * Ensure the RemoteXPC tunnel is running so XCUITest can reach WebDriverAgent.
@@ -125,6 +144,7 @@ export async function ensureIosTunnel(options = {}) {
             `${shQuote(appiumBin)} driver run xcuitest tunnel-creation`);
     }
     await pollHealthy(isHealthy, port, options.readyTimeoutMs ?? 45_000, logFile);
-    log(`iOS device tunnel is up (registry on port ${port}).`);
+    log(`iOS device tunnel is up (registry on port ${port}). It keeps running in the background ` +
+        `so later connects don't prompt again; stop it anytime with: ${TUNNEL_STOP_COMMAND}`);
     return { reused: false, started: true, skipped: false, port };
 }

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

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import { buildTunnelScript, DEFAULT_TUNNEL_REGISTRY_PORT, ensureIosTunnel } from "./ios-tunnel.js";
 describe("buildTunnelScript", () => {
-    it("backgrounds tunnel-creation as a detached daemon with APPIUM_HOME set", () => {
+    it("launches tunnel-creation as a setsid-detached daemon with APPIUM_HOME set", () => {
         const script = buildTunnelScript({
             appiumHome: "/home/u/.aximo/appium-home",
             nodePath: "/usr/bin/node",
@@ -9,8 +9,13 @@ describe("buildTunnelScript", () => {
             logFile: "/home/u/.aximo/ios-tunnel/tunnel.log",
         });
         expect(script).toContain("export APPIUM_HOME='/home/u/.aximo/appium-home'");
-        expect(script).toContain("nohup '/usr/bin/node' '/cli/node_modules/appium/index.js' driver run xcuitest tunnel-creation");
-        expect(script).toContain("> '/home/u/.aximo/ios-tunnel/tunnel.log' 2>&1 &");
+        // Detached via perl double-fork + setsid so the admin-elevation trampoline
+        // can't reap it (a plain `nohup … &` was killed on script exit).
+        expect(script).toContain("setsid()");
+        expect(script).toContain("'/usr/bin/node' '/cli/node_modules/appium/index.js' driver run xcuitest tunnel-creation");
+        // Log file is passed as the perl daemon's first argv (STDOUT/STDERR sink).
+        expect(script).toContain("'/home/u/.aximo/ios-tunnel/tunnel.log' '/usr/bin/node'");
+        expect(script).not.toContain("nohup");
     });
     it("escapes single quotes in paths", () => {
         const script = buildTunnelScript({

package/dist/mobile-control/ios-wda-preinstall.js

@@ -68,8 +68,11 @@ export async function preinstallWda(options) {
     }
     const scratch = mkdtempSync(join(tmpdir(), "aximo-wda-preinstall-"));
     try {
-        // Wrap the bare .app into Payload/ so it can go through the same resign path
-        // as any other IPA (ditto ships with macOS and handles both directions).
+        // Wrap the bare .app into Payload/ so it goes through the same resign path as
+        // any other IPA. Extract with ditto (it reads the Apple-produced zip cleanly)
+        // but REPACKAGE with `zip`: applesign's own extractor can't parse ditto's
+        // PKZip variant and rejects a ditto-built IPA as "Invalid IPA" (no .app found
+        // in Payload). `zip -qr Payload` from the wrap dir keeps Payload/ at the root.
         const payloadRoot = join(scratch, "wrap");
         const extractDir = join(payloadRoot, "Payload");
         mkdirSync(extractDir, { recursive: true });
@@ -78,7 +81,7 @@ export async function preinstallWda(options) {
             throw new Error(`Prebuilt WDA zip did not contain ${RUNNER_APP} — re-download or report.`);
         }
         const wrappedIpa = join(scratch, "wda.ipa");
-        await exec("ditto", ["-c", "-k", payloadRoot, wrappedIpa]);
+        await exec("zip", ["-qr", wrappedIpa, "Payload"], { cwd: payloadRoot });
         const runnerBundleId = `${options.wdaBundleId}.xctrunner`;
         const resignedIpa = join(scratch, "wda-resigned.ipa");
         log(`Signing WebDriverAgent as ${runnerBundleId}…`);

package/dist/mobile-control/ios-wda-preinstall.test.js

@@ -33,15 +33,19 @@ describe("preinstallWda", () => {
     afterEach(() => {
         rmSync(cacheDir, { recursive: true, force: true });
     });
-    /** ditto fake: -x -k extract creates the runner app; -c -k creates the archive. */
-    const dittoExec = async (file, args) => {
+    /** exec fake: `ditto -x` extracts the runner app; `zip` writes the IPA archive. */
+    const execFake = async (file, args, opts) => {
         if (file === "ditto" && args[0] === "-x") {
             const dest = args[3];
             if (dest)
                 mkdirSync(join(dest, "WebDriverAgentRunner-Runner.app"), { recursive: true });
         }
-        if (file === "ditto" && args[0] === "-c") {
-            const out = args[3];
+        if (file === "zip") {
+            // Like real zip: the relative Payload argument only resolves against opts.cwd.
+            if (!opts?.cwd || !existsSync(join(opts.cwd, "Payload"))) {
+                throw new Error("zip error: Nothing to do (Payload not found in cwd)");
+            }
+            const out = args[1];
             if (out)
                 writeFileSync(out, "zip");
         }
@@ -53,7 +57,7 @@ describe("preinstallWda", () => {
             identityHash: "A".repeat(40),
             profilePath: "/profiles/wda.mobileprovision",
             wdaBundleId: "com.aximo.wda.testteam99",
-            exec: dittoExec,
+            exec: execFake,
             cacheDir,
             wdaVersion: "15.0.0",
             fetchImpl: vi.fn(async (_input) => new Response(new ArrayBuffer(8), { status: 200 })),
@@ -76,7 +80,7 @@ describe("preinstallWda", () => {
             profilePath: "/profiles/wda.mobileprovision",
             bundleId: "com.aximo.wda.testteam99.xctrunner",
         }));
-        expect(opts.install).toHaveBeenCalledWith("UDID-1", expect.stringContaining("wda-resigned"), dittoExec);
+        expect(opts.install).toHaveBeenCalledWith("UDID-1", expect.stringContaining("wda-resigned"), execFake);
         // Second run: cache hit, no new download.
         await preinstallWda(opts);
         expect(opts.fetchImpl).toHaveBeenCalledOnce();
@@ -93,7 +97,7 @@ describe("preinstallWda", () => {
         await expect(preinstallWda(opts)).rejects.toThrow(/aximo mobile setup/);
     });
     it("fails loudly when the zip has an unexpected layout", async () => {
-        const badDitto = async (file, args) => {
+        const badExec = async (file, args) => {
             if (file === "ditto" && args[0] === "-x") {
                 const dest = args[3];
                 if (dest)
@@ -101,7 +105,7 @@ describe("preinstallWda", () => {
             }
             return { stdout: Buffer.from(""), stderr: "" };
         };
-        const opts = { ...makeOptions(), exec: badDitto };
+        const opts = { ...makeOptions(), exec: badExec };
         await expect(preinstallWda(opts)).rejects.toThrow(/did not contain/);
     });
 });

package/dist/mobile-control/tunnel.js

@@ -49,10 +49,43 @@ function defaultConnect(wsUrl, deviceToken) {
         timeout: 10000,
     });
 }
+// Mirrors the gateway's lock lease: a session quiet for longer than this has lost
+// its server-side lock, so a new session id is a legitimate takeover, not a stray.
+const SESSION_LEASE_MS = 25 * 60 * 1000;
 export function registerHandlers(socket, controller, installApp) {
+    // Device-side guard against interleaved sessions: the gateway announces owner
+    // changes (session_acquired/session_released) and tags each command with its
+    // session id, so commands from a session that no longer owns the device are
+    // dropped even if a gateway instance lost its in-memory lock.
+    let activeSession = null;
+    socket.on("session_acquired", (args) => {
+        const sessionId = args?.sessionId;
+        if (typeof sessionId === "string" && sessionId) {
+            activeSession = { id: sessionId, lastSeenAt: Date.now() };
+        }
+    });
+    socket.on("session_released", (args) => {
+        // Only the owner's release clears the guard; a takeover by a new session is
+        // announced via session_acquired, so an unmatched release is ignored.
+        const sessionId = args?.sessionId;
+        if (activeSession && activeSession.id === sessionId) {
+            activeSession = null;
+        }
+    });
     const on = (event, handler) => {
         socket.on(event, (rawArgs, ack) => {
-            const args = (rawArgs ?? {});
+            // Destructure the routing-only tag off a clone so the caller's payload
+            // object is never mutated.
+            const { __sessionId: sessionId, ...args } = (rawArgs ?? {});
+            if (typeof sessionId === "string" && sessionId) {
+                if (activeSession &&
+                    activeSession.id !== sessionId &&
+                    Date.now() - activeSession.lastSeenAt < SESSION_LEASE_MS) {
+                    ack?.(fail(new Error("Device is busy with another session")));
+                    return;
+                }
+                activeSession = { id: sessionId, lastSeenAt: Date.now() };
+            }
             void handler(args)
                 .then((result) => ack?.(result))
                 .catch((err) => ack?.(fail(err)));

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

@@ -153,3 +153,85 @@ describe("registerHandlers", () => {
         });
     });
 });
+describe("registerHandlers session guard", () => {
+    const BUSY = { ok: false, error: "Device is busy with another session" };
+    function fire(socket, event, args) {
+        socket.handlers.get(event)?.(args);
+    }
+    it("strips __sessionId for the handler without mutating the incoming payload", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        const payload = { x: 5, y: 9, __sessionId: "s1" };
+        await expect(socket.emit("tap", payload)).resolves.toEqual({ ok: true });
+        expect(tap).toHaveBeenCalledWith(5, 9);
+        expect(payload.__sessionId).toBe("s1");
+    });
+    it("rejects a second session's command while the first is active", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("accepts a new session after session_released for the active one", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", { sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+    it("ignores session_released for a session that is not active", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", { sessionId: "other" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("ignores session_released without a sessionId (malformed release)", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", {});
+        fire(socket, "session_released", { sessionId: null });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("switches owner on session_acquired and rejects the superseded session", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_acquired", { sessionId: "s2" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s1" })).resolves.toEqual(BUSY);
+        await expect(socket.emit("tap", { x: 5, y: 6, __sessionId: "s2" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+    it("allows takeover once the active session is idle past the lease", async () => {
+        vi.useFakeTimers();
+        try {
+            const tap = vi.fn(async () => { });
+            const socket = wire(stubController({ tap }));
+            await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+            vi.advanceTimersByTime(26 * 60 * 1000);
+            await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual({
+                ok: true,
+            });
+            expect(tap).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("leaves untagged commands ungated (pre-tagging gateways)", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4 })).resolves.toEqual({ ok: true });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autifyhq/aximo-cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Autify Aximo Command Line Interface (CLI)",
   "keywords": [
     "autify",