@autifyhq/aximo-cli 0.6.0 → 0.8.0

package/dist/commands/mobile/doctor.js

@@ -3,10 +3,12 @@ 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 { resolveIosSigning } from "../../mobile-control/ios-signing.js";
+import { resolveIosSigningAuto } from "../../mobile-control/ios-signing.js";
+import { DEFAULT_TUNNEL_REGISTRY_PORT, isTunnelHealthy } from "../../mobile-control/ios-tunnel.js";
 function which(cmd) {
     const probe = platform() === "win32" ? "where" : "which";
     const result = spawnSync(probe, [cmd], { encoding: "utf-8" });
@@ -78,7 +80,7 @@ function checkAndroid() {
         });
     return checks;
 }
-function checkIos() {
+async function checkIos() {
     if (platform() !== "darwin") {
         return [
             { name: "ios", status: "info", message: "iOS device control is only available on macOS" },
@@ -104,43 +106,87 @@ function checkIos() {
         });
     const idb = which("idb");
     checks.push(idb
-        ? { name: "idb", status: "pass", message: idb }
+        ? { name: "idb", status: "info", message: idb }
         : {
             name: "idb",
-            status: "warn",
-            message: "idb not found",
-            hint: "Install idb (brew install idb-companion && pipx install fb-idb). It's used to discover connected iPhones and install .ipa builds.",
+            status: "info",
+            message: "idb not found (optional)",
+            hint: "Device discovery and installs use Xcode's devicectl; idb is only a fallback. Install it with `brew install idb-companion && pipx install fb-idb` if devicectl can't see your device.",
         });
-    const teamId = resolveIosSigning().teamId;
-    checks.push(teamId
-        ? { name: "ios signing", status: "pass", message: `signing team id is set (${teamId})` }
+    // Zero-config signing: the identity + team come from the keychain; env vars
+    // (AXIMO_IOS_TEAM_ID etc.) are overrides, not requirements.
+    const signing = await resolveIosSigningAuto();
+    checks.push(signing.teamId
+        ? {
+            name: "ios signing",
+            status: "pass",
+            message: signing.identityHash
+                ? `signing identity found (team ${signing.teamId}, WDA id ${signing.wdaBundleId})`
+                : `signing team id set (${signing.teamId}) but no matching keychain identity`,
+        }
         : {
             name: "ios signing",
             status: "warn",
-            message: "no signing team id is set",
-            hint: "Driving a physical iPhone needs an Apple Developer Team ID to sign WebDriverAgent. Set AXIMO_IOS_TEAM_ID (or MobileLink's XCODE_TEAM_ID), and optionally AXIMO_IOS_SIGNING_ID / AXIMO_IOS_WDA_BUNDLE_ID.",
+            message: "no Apple Development signing identity found",
+            hint: "Open Xcode → Settings → Accounts, add your Apple ID, then Manage Certificates → + → Apple Development. A free Apple ID works (with weekly re-signing); AXIMO_IOS_TEAM_ID overrides team selection on multi-team machines.",
         });
     checks.push({
         name: "ios webdriveragent",
         status: "info",
-        message: "Physical iPhones are driven via Appium's XCUITest driver, which builds and installs a WebDriverAgent runner on the device.",
-        hint: "Enable Developer Mode (Settings → Privacy & Security), trust this computer, and ensure the WDA bundle id is backed by a valid provisioning profile.",
+        message: "On iOS 17+ a prebuilt WebDriverAgent is downloaded, re-signed and preinstalled (no Xcode build); older devices fall back to the Xcode build flow.",
+        hint: "One-time on the phone: enable Developer Mode (Settings → Privacy & Security), trust this computer, and trust the developer certificate (Settings → General → VPN & Device Management) after the first install.",
     });
     return checks;
 }
+// The RemoteXPC tunnel is host-level (a registry port), so doctor can probe it
+// without a connected device. `connect` starts it automatically, so a missing
+// tunnel is informational, not a failure.
+export async function checkIosTunnel(isHealthy = isTunnelHealthy) {
+    const running = await isHealthy(DEFAULT_TUNNEL_REGISTRY_PORT);
+    return running
+        ? {
+            name: "ios tunnel",
+            status: "pass",
+            message: `RemoteXPC tunnel running (registry port ${DEFAULT_TUNNEL_REGISTRY_PORT})`,
+        }
+        : {
+            name: "ios tunnel",
+            status: "info",
+            message: "RemoteXPC tunnel not running",
+            hint: "iOS 17+ needs it to reach WebDriverAgent; `aximo mobile connect` starts it automatically (prompts for admin).",
+        };
+}
 export async function runMobileDoctor(options = {}) {
     const checks = [await checkAppium()];
     if (options.platform !== "ios") {
         checks.push(...checkAndroid());
     }
     if (options.platform !== "android") {
-        checks.push(...checkIos());
+        checks.push(...(await checkIos()));
+        if (platform() === "darwin") {
+            checks.push(await checkIosTunnel(options.isTunnelHealthy));
+        }
     }
     const summary = { pass: 0, warn: 0, fail: 0, info: 0 };
     for (const c of checks)
         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",
@@ -154,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.d.ts

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

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

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { checkIosTunnel, renderDoctorReport } from "./doctor.js";
+describe("checkIosTunnel", () => {
+    it("passes when the RemoteXPC tunnel is reachable", async () => {
+        const check = await checkIosTunnel(async () => true);
+        expect(check.status).toBe("pass");
+        expect(check.name).toBe("ios tunnel");
+    });
+    it("is informational (not a failure) when the tunnel is down", async () => {
+        const check = await checkIosTunnel(async () => false);
+        expect(check.status).toBe("info");
+        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

@@ -1,4 +1,6 @@
 import { type ExecFn } from "../../mobile-control/exec.js";
+import { ensureInstallableIpa } from "../../mobile-control/ios-auto-resign.js";
+import { installIosApp } from "../../mobile-control/ios-devicectl.js";
 import type { Envelope } from "../../types.js";
 import type { MobilePlatform } from "./paths.js";
 export interface MobileInstallResult {
@@ -9,6 +11,10 @@ export interface MobileInstallResult {
     udid?: string;
     app: string;
     output: string;
+    /** iOS only: set when the app was auto-re-signed for this device. */
+    resigned?: boolean;
+    originalBundleId?: string;
+    installedBundleId?: string;
 }
 export interface MobileInstallOptions {
     app?: string | undefined;
@@ -18,9 +24,11 @@ export interface MobileInstallOptions {
 }
 /**
  * Install an app on the connected phone: Android `.apk` via `adb install -r`,
- * iOS `.ipa` via `idb install`. The iOS build must be signed for the device.
+ * iOS `.ipa` via devicectl — auto-re-signed for the device first when its
+ * signature doesn't already cover it (disable with AXIMO_IOS_NO_RESIGN).
  */
-export declare function runMobileInstall(options: MobileInstallOptions, exec?: ExecFn): Promise<Envelope<MobileInstallResult>>;
+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

@@ -1,9 +1,14 @@
 import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import { defineCommand } from "citty";
 import { resolveAndroidSerial, resolveIosUdid } from "../../mobile-control/devices.js";
 import { execBinary } from "../../mobile-control/exec.js";
-import { formatError, formatSuccess, printResult } from "../../output.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 } from "../../output.js";
+import { printMobileResult } from "./output.js";
 import { parsePlatformArg } from "./register-core.js";
 function inferPlatform(appPath) {
     const ext = extname(appPath).toLowerCase();
@@ -15,9 +20,10 @@ function inferPlatform(appPath) {
 }
 /**
  * Install an app on the connected phone: Android `.apk` via `adb install -r`,
- * iOS `.ipa` via `idb install`. The iOS build must be signed for the device.
+ * iOS `.ipa` via devicectl — auto-re-signed for the device first when its
+ * signature doesn't already cover it (disable with AXIMO_IOS_NO_RESIGN).
  */
-export async function runMobileInstall(options, exec = execBinary) {
+export async function runMobileInstall(options, exec = execBinary, ensureInstallable = ensureInstallableIpa, installIos = installIosApp) {
     if (!options.app) {
         return formatError("validation_error", "App path is required (--app <path-to-.apk|.ipa>).", false);
     }
@@ -40,24 +46,60 @@ export async function runMobileInstall(options, exec = execBinary) {
         return formatError("validation_error", err instanceof Error ? err.message : String(err), false);
     }
     try {
-        const { stdout } = platform === "ios"
-            ? await exec("idb", ["install", "--udid", target, appPath])
-            : await exec("adb", ["-s", target, "install", "-r", appPath]);
-        return formatSuccess({
-            platform,
-            ...(platform === "ios" ? { udid: target } : { serial: target }),
-            app: appPath,
-            output: stdout.toString("utf-8").trim(),
+        if (platform === "android") {
+            const { stdout } = await exec("adb", ["-s", target, "install", "-r", appPath]);
+            return formatSuccess({
+                platform,
+                serial: target,
+                app: appPath,
+                output: stdout.toString("utf-8").trim(),
+            });
+        }
+        const ensured = await ensureInstallable({
+            ipaPath: appPath,
+            udid: target,
+            log: (message) => console.error(message),
         });
+        try {
+            const output = await installIos(target, ensured.ipaPath, exec);
+            return formatSuccess({
+                platform,
+                udid: target,
+                app: appPath,
+                output,
+                ...(ensured.resigned
+                    ? {
+                        resigned: true,
+                        originalBundleId: ensured.originalBundleId,
+                        installedBundleId: ensured.installedBundleId,
+                    }
+                    : {}),
+            });
+        }
+        finally {
+            if (ensured.resigned)
+                await rm(ensured.ipaPath, { force: true }).catch(() => { });
+        }
     }
     catch (err) {
-        return formatError("api_error", err instanceof Error ? err.message : String(err), false);
+        const message = err instanceof Error ? err.message : String(err);
+        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",
-        description: "Install an app on the connected phone (.apk via adb, .ipa via idb)",
+        description: "Install an app on the connected phone (.apk via adb, .ipa auto-re-signed + devicectl)",
     },
     args: {
         app: { type: "string", description: "Path to the .apk or .ipa to install", required: true },
@@ -66,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/install.test.js

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -74,17 +74,55 @@ describe("runMobileInstall", () => {
         expect(install().args.slice(0, 2)).toEqual(["-s", "R1"]);
         expect(install().args).toEqual(expect.arrayContaining(["install", "-r"]));
     });
-    it("installs an .ipa via `idb install --udid <udid>`", async () => {
-        const { exec, install } = execWith({ out: "Installed" });
-        const res = await runMobileInstall({ app: ipaPath }, exec);
+    it("installs an .ipa via devicectl, auto-resigning when needed", async () => {
+        const { exec } = execWith();
+        const ensureInstallable = vi.fn(async (_opts) => ({
+            ipaPath: join(dir, "app-resigned.ipa"),
+            resigned: true,
+            originalBundleId: "com.example.app",
+            installedBundleId: "com.aximo.resign.team.xctrunner",
+        }));
+        const installIos = vi.fn(async () => "App installed:");
+        const res = await runMobileInstall({ app: ipaPath }, exec, ensureInstallable, installIos);
         expect(res.ok).toBe(true);
         if (res.ok) {
             expect(res.data.platform).toBe("ios");
             expect(res.data.udid).toBe("00008030-ABC");
             expect(res.data.serial).toBeUndefined();
+            expect(res.data.resigned).toBe(true);
+            expect(res.data.originalBundleId).toBe("com.example.app");
+            expect(res.data.installedBundleId).toBe("com.aximo.resign.team.xctrunner");
         }
-        expect(install().file).toBe("idb");
-        expect(install().args).toEqual(["install", "--udid", "00008030-ABC", ipaPath]);
+        expect(vi.mocked(ensureInstallable).mock.calls[0]?.[0]).toMatchObject({
+            ipaPath,
+            udid: "00008030-ABC",
+        });
+        expect(installIos).toHaveBeenCalledWith("00008030-ABC", join(dir, "app-resigned.ipa"), exec);
+    });
+    it("omits resign metadata when the .ipa was already installable", async () => {
+        const { exec } = execWith();
+        const ensureInstallable = vi.fn(async () => ({
+            ipaPath,
+            resigned: false,
+            originalBundleId: "com.example.app",
+            installedBundleId: "com.example.app",
+        }));
+        const installIos = vi.fn(async () => "App installed:");
+        const res = await runMobileInstall({ app: ipaPath }, exec, ensureInstallable, installIos);
+        expect(res.ok).toBe(true);
+        if (res.ok)
+            expect(res.data.resigned).toBeUndefined();
+    });
+    it("maps an iOS resign failure to an error envelope with hint", async () => {
+        const { exec } = execWith();
+        const ensureInstallable = vi.fn(async () => {
+            throw new Error("app.ipa is FairPlay-encrypted (an App Store download)");
+        });
+        const installIos = vi.fn(async () => "");
+        const res = await runMobileInstall({ app: ipaPath }, exec, ensureInstallable, installIos);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.message).toMatch(/FairPlay/);
     });
     it("honors an explicit --platform override", async () => {
         const { exec, install } = execWith();

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

@@ -4,7 +4,10 @@ import type { ExecFn } from "../../mobile-control/exec.js";
 export interface MobileListResult {
     androidDevices: AndroidDevice[];
     iosDevices: IosPhysicalDevice[];
+    /** Per-toolchain discovery failures (broken adb/idb) — an empty list alone is ambiguous. */
+    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,30 +1,56 @@
 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";
-async function safe(fn, fallback) {
-    try {
-        return await fn();
-    }
-    catch {
-        return fallback;
-    }
-}
 export async function runMobileList(exec) {
+    const warnings = [];
+    const safe = async (label, fn, fallback) => {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            warnings.push(`${label}: ${err instanceof Error ? err.message : String(err)}`);
+            return fallback;
+        }
+    };
     const [allAndroid, iosDevices] = await Promise.all([
-        safe(() => listAndroidDevices(exec), []),
-        safe(() => listIosPhysicalDevices(exec), []),
+        safe("android (adb)", () => listAndroidDevices(exec), []),
+        safe("ios (idb)", () => listIosPhysicalDevices(exec), []),
     ]);
     // Physical phones only: drop emulator serials.
     const androidDevices = allAndroid.filter((d) => !d.serial.startsWith("emulator-"));
-    return formatSuccess({ androidDevices, iosDevices });
+    return formatSuccess({
+        androidDevices,
+        iosDevices,
+        ...(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";