@autifyhq/aximo-cli 0.7.0 → 0.9.0

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

@@ -5,12 +5,13 @@ 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";
 import { runControlTunnel } from "../../mobile-control/tunnel.js";
 import { runMobileDoctor } from "./doctor.js";
+import { confirmIosSigning } from "./signing-consent.js";
 import { listMobileDeviceConfigs, readMobileDeviceConfig, } from "./paths.js";
 export function getTunnelOrigin() {
     return getBaseUrl().replace(/^http/, "ws");
@@ -28,9 +29,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) {
@@ -87,11 +87,34 @@ async function preflightIosDevice(udid) {
     }
     return iosMajorVersion(info.osVersion);
 }
-export async function connectWithConfig(config) {
+export async function connectWithConfig(config, options) {
     await assertPrerequisites(config.platform);
     let iosMajor = null;
+    let tunnelRunning = false;
+    let signing;
     if (config.platform === "ios") {
         iosMajor = await preflightIosDevice(config.target);
+        // Resolve and confirm the signing identity before any signing side effects —
+        // the RemoteXPC tunnel (admin prompt), Appium, WDA install, and profile
+        // minting against the user's Apple Developer account all come after, so
+        // declining costs nothing.
+        signing = await resolveIosSigningAuto({ udid: config.target });
+        if (signing.teamId) {
+            const accepted = await confirmIosSigning({
+                signing,
+                ...(options?.assumeYes !== undefined ? { assumeYes: options.assumeYes } : {}),
+            });
+            if (!accepted) {
+                console.error("Signing not accepted — not connecting. Re-run with --yes to skip this prompt, " +
+                    "or set AXIMO_IOS_TEAM_ID to sign with a different team.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        else {
+            console.error("No Apple signing identity found — physical-device WebDriverAgent signing will fail. " +
+                "Open Xcode → Settings → Accounts to add your Apple ID (see `aximo mobile doctor`).");
+        }
         // Physical iPhones on iOS 17+ need the RemoteXPC tunnel before XCUITest can
         // reach WebDriverAgent; start it (prompting for admin) unless one is running.
         // Older devices use the classic lockdown path — no tunnel, no admin prompt.
@@ -100,6 +123,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.");
         }
@@ -113,15 +137,7 @@ export async function connectWithConfig(config) {
     // installed profiles; env vars only override.
     let iosSigning;
     let wdaLocalPort;
-    if (config.platform === "ios") {
-        const signing = await resolveIosSigningAuto({ udid: config.target });
-        if (signing.teamId) {
-            console.error(`Signing as team ${signing.teamId} (WDA id ${signing.wdaBundleId}).`);
-        }
-        else {
-            console.error("No Apple signing identity found — physical-device WebDriverAgent signing will fail. " +
-                "Open Xcode → Settings → Accounts to add your Apple ID (see `aximo mobile doctor`).");
-        }
+    if (config.platform === "ios" && signing) {
         const preinstalled = await resolvePreinstalledWdaStrategy(signing, {
             udid: config.target,
             iosMajor,
@@ -182,5 +198,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.d.ts

@@ -5,5 +5,10 @@ declare const _default: import("citty").CommandDef<{
         readonly type: "string";
         readonly description: "Registered device id (required if multiple)";
     };
+    readonly yes: {
+        readonly type: "boolean";
+        readonly alias: "y";
+        readonly description: "Skip the iOS code-signing confirmation prompt";
+    };
 }>;
 export default _default;

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 " +
@@ -16,22 +17,27 @@ export default defineCommand({
     },
     args: {
         "device-id": { type: "string", description: "Registered device id (required if multiple)" },
+        yes: {
+            type: "boolean",
+            alias: "y",
+            description: "Skip the iOS code-signing confirmation prompt",
+        },
     },
     async run({ args }) {
         const resolved = resolveDeviceConfig(args["device-id"]);
         if (!resolved.ok) {
-            printResult(resolved);
+            printMobileResult(resolved);
             return;
         }
         const warning = iosPhysicalWarning(resolved.config);
         if (warning)
             console.error(warning);
         try {
-            await connectWithConfig(resolved.config);
+            await connectWithConfig(resolved.config, { assumeYes: Boolean(args.yes) });
         }
         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/signing-consent.d.ts

@@ -0,0 +1,18 @@
+import type { IosSigningConfig } from "../../mobile-control/ios-signing.js";
+export interface ConfirmIosSigningOptions {
+    signing: IosSigningConfig;
+    /** Skip the prompt entirely (--yes). The notice still prints. */
+    assumeYes?: boolean;
+    /** Whether a human can answer; defaults to stdin being a TTY. */
+    interactive?: boolean;
+    ask?: (question: string) => Promise<string>;
+    log?: (message: string) => void;
+}
+/**
+ * Informed consent before using the user's Apple signing identity: connecting
+ * can re-sign apps/WDA with it, register the device to the team's Apple
+ * Developer account, and create aximo App IDs in it. Defaults to yes (Enter
+ * proceeds); only an explicit n/no declines. Unattended connects (no TTY)
+ * proceed after printing the notice, so daemonized devices keep working.
+ */
+export declare function confirmIosSigning(options: ConfirmIosSigningOptions): Promise<boolean>;

package/dist/commands/mobile/signing-consent.js

@@ -0,0 +1,28 @@
+import { createInterface } from "node:readline/promises";
+function defaultAsk(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return rl.question(question).finally(() => rl.close());
+}
+/**
+ * Informed consent before using the user's Apple signing identity: connecting
+ * can re-sign apps/WDA with it, register the device to the team's Apple
+ * Developer account, and create aximo App IDs in it. Defaults to yes (Enter
+ * proceeds); only an explicit n/no declines. Unattended connects (no TTY)
+ * proceed after printing the notice, so daemonized devices keep working.
+ */
+export async function confirmIosSigning(options) {
+    const { signing } = options;
+    const log = options.log ?? ((message) => console.error(message));
+    log(`Code signing: team ${signing.teamId} (WDA id ${signing.wdaBundleId}). Connecting may ` +
+        "re-sign apps and WebDriverAgent with this identity, register this device to the " +
+        "team's Apple Developer account, and create aximo App IDs in it. " +
+        "Set AXIMO_IOS_TEAM_ID to sign with a different team.");
+    if (options.assumeYes)
+        return true;
+    const interactive = options.interactive ?? process.stdin.isTTY === true;
+    if (!interactive)
+        return true;
+    const ask = options.ask ?? defaultAsk;
+    const answer = (await ask("Proceed with this signing identity? [Y/n] ")).trim().toLowerCase();
+    return answer !== "n" && answer !== "no";
+}

package/dist/commands/mobile/signing-consent.test.d.ts

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