@autifyhq/aximo-cli 0.5.0 → 0.7.0

package/dist/commands/mobile/doctor.js

@@ -6,6 +6,8 @@ import { join } from "node:path";
 import { formatSuccess, printResult } 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";
+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" });
@@ -77,7 +79,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" },
@@ -97,25 +99,72 @@ function checkIos() {
         ? { name: "xcrun", status: "pass", message: xcrun }
         : {
             name: "xcrun",
-            status: "warn",
+            status: "fail",
             message: "xcrun not found",
-            hint: "Install Xcode command line tools: xcode-select --install. Appium's XCUITest driver delegates to Xcode.",
+            hint: "Install Xcode command line tools: xcode-select --install. Appium's XCUITest driver delegates to Xcode and cannot run without it.",
+        });
+    const idb = which("idb");
+    checks.push(idb
+        ? { name: "idb", status: "info", message: idb }
+        : {
+            name: "idb",
+            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.",
+        });
+    // 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 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: "WDA needs an Apple Developer signing identity; enable Developer Mode (Settings → Privacy & Security) and trust the device.",
+        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)

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

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

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { checkIosTunnel } 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");
+    });
+});

package/dist/commands/mobile/index.js

@@ -7,6 +7,7 @@ export default defineCommand({
     subCommands: {
         list: () => import("./list.js").then((m) => m.default),
         register: () => import("./register.js").then((m) => m.default),
+        install: () => import("./install.js").then((m) => m.default),
         unregister: () => import("./unregister.js").then((m) => m.default),
         connect: () => import("./connect.js").then((m) => m.default),
         setup: () => import("./setup.js").then((m) => m.default),

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

@@ -0,0 +1,50 @@
+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 {
+    platform: MobilePlatform;
+    /** adb serial (Android). */
+    serial?: string;
+    /** device udid (iOS). */
+    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;
+    platform?: string | undefined;
+    serial?: string | undefined;
+    udid?: string | undefined;
+}
+/**
+ * Install an app on the connected phone: Android `.apk` via `adb install -r`,
+ * 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, ensureInstallable?: typeof ensureInstallableIpa, installIos?: typeof installIosApp): Promise<Envelope<MobileInstallResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly app: {
+        readonly type: "string";
+        readonly description: "Path to the .apk or .ipa to install";
+        readonly required: true;
+    };
+    readonly platform: {
+        readonly type: "string";
+        readonly description: "android | ios (inferred from the file extension)";
+    };
+    readonly serial: {
+        readonly type: "string";
+        readonly description: "Android adb serial (defaults to the connected one)";
+    };
+    readonly udid: {
+        readonly type: "string";
+        readonly description: "iOS device udid (defaults to the connected one)";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/install.js

@@ -0,0 +1,107 @@
+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 { 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 { parsePlatformArg } from "./register-core.js";
+function inferPlatform(appPath) {
+    const ext = extname(appPath).toLowerCase();
+    if (ext === ".apk")
+        return "android";
+    if (ext === ".ipa")
+        return "ios";
+    return null;
+}
+/**
+ * Install an app on the connected phone: Android `.apk` via `adb install -r`,
+ * 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, ensureInstallable = ensureInstallableIpa, installIos = installIosApp) {
+    if (!options.app) {
+        return formatError("validation_error", "App path is required (--app <path-to-.apk|.ipa>).", false);
+    }
+    const appPath = resolve(options.app);
+    if (!existsSync(appPath)) {
+        return formatError("validation_error", `App not found: ${appPath}`, false);
+    }
+    const platform = options.platform ? parsePlatformArg(options.platform) : inferPlatform(appPath);
+    if (!platform) {
+        return formatError("validation_error", "Could not determine platform; pass --platform android|ios (or use a .apk/.ipa file).", false);
+    }
+    let target;
+    try {
+        target =
+            platform === "ios"
+                ? await resolveIosUdid(options.udid, exec)
+                : await resolveAndroidSerial(options.serial, exec);
+    }
+    catch (err) {
+        return formatError("validation_error", err instanceof Error ? err.message : String(err), false);
+    }
+    try {
+        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) {
+        const message = err instanceof Error ? err.message : String(err);
+        return formatError("api_error", message, false, mobileErrorHint(message, platform));
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "install",
+        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 },
+        platform: { type: "string", description: "android | ios (inferred from the file extension)" },
+        serial: { type: "string", description: "Android adb serial (defaults to the connected one)" },
+        udid: { type: "string", description: "iOS device udid (defaults to the connected one)" },
+    },
+    async run({ args }) {
+        printResult(await runMobileInstall({
+            app: args.app,
+            platform: args.platform,
+            serial: args.serial,
+            udid: args.udid,
+        }));
+    },
+});

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

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

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

@@ -0,0 +1,142 @@
+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";
+import { runMobileInstall } from "./install.js";
+const ONE_ANDROID = "List of devices attached\nR1 device\n";
+const ONE_IOS = `${JSON.stringify({ udid: "00008030-ABC", name: "iPhone", type: "device" })}\n`;
+let dir;
+let apkPath;
+let ipaPath;
+let txtPath;
+beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "aximo-mob-install-"));
+    apkPath = join(dir, "app.apk");
+    ipaPath = join(dir, "app.ipa");
+    txtPath = join(dir, "app.txt");
+    for (const p of [apkPath, ipaPath, txtPath])
+        writeFileSync(p, "x");
+});
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+/** Mock adb/idb: serve device discovery and capture the `install` invocation. */
+function execWith(opts = {}) {
+    let captured = { file: "", args: [] };
+    const exec = async (file, args) => {
+        if (file === "adb" && args[0] === "devices") {
+            return { stdout: Buffer.from(ONE_ANDROID), stderr: "" };
+        }
+        if (file === "idb" && args[0] === "list-targets") {
+            return { stdout: Buffer.from(ONE_IOS), stderr: "" };
+        }
+        if ((file === "adb" || file === "idb") && args.includes("install")) {
+            captured = { file, args };
+            if (opts.throwMsg)
+                throw new Error(opts.throwMsg);
+            return { stdout: Buffer.from(opts.out ?? "Success"), stderr: "" };
+        }
+        throw new Error(`unexpected exec: ${file} ${args.join(" ")}`);
+    };
+    return { exec, install: () => captured };
+}
+describe("runMobileInstall", () => {
+    it("requires --app", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({}, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.code).toBe("validation_error");
+    });
+    it("errors when the app file is missing", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({ app: "definitely-not-here-xyz.apk" }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.message).toMatch(/not found/i);
+    });
+    it("errors when the platform cannot be inferred", async () => {
+        const { exec } = execWith();
+        const res = await runMobileInstall({ app: txtPath }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok)
+            expect(res.error.message).toMatch(/determine platform/i);
+    });
+    it("installs an .apk via `adb -s <serial> install -r`", async () => {
+        const { exec, install } = execWith({ out: "Performing Streamed Install\nSuccess" });
+        const res = await runMobileInstall({ app: apkPath }, exec);
+        expect(res.ok).toBe(true);
+        if (res.ok) {
+            expect(res.data.platform).toBe("android");
+            expect(res.data.serial).toBe("R1");
+            expect(res.data.udid).toBeUndefined();
+            expect(res.data.output).toContain("Success");
+        }
+        expect(install().file).toBe("adb");
+        expect(install().args.slice(0, 2)).toEqual(["-s", "R1"]);
+        expect(install().args).toEqual(expect.arrayContaining(["install", "-r"]));
+    });
+    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(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();
+        const res = await runMobileInstall({ app: txtPath, platform: "android" }, exec);
+        expect(res.ok).toBe(true);
+        expect(install().file).toBe("adb");
+    });
+    it("maps an install failure to an error envelope", async () => {
+        const { exec } = execWith({ throwMsg: "adb: failed to install: INSTALL_FAILED_INVALID_APK" });
+        const res = await runMobileInstall({ app: apkPath }, exec);
+        expect(res.ok).toBe(false);
+        if (!res.ok) {
+            expect(res.error.code).toBe("api_error");
+            expect(res.error.message).toMatch(/INSTALL_FAILED/);
+        }
+    });
+});

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

@@ -4,6 +4,8 @@ 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>>;
 declare const _default: import("citty").CommandDef<{}>;

package/dist/commands/mobile/list.js

@@ -1,22 +1,28 @@
 import { defineCommand } from "citty";
 import { formatSuccess, printResult } 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 default defineCommand({
     meta: {

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

@@ -6,6 +6,7 @@ export interface MobileRegisterCmdOptions {
     name: string;
     platform: string;
     serial?: string | undefined;
+    udid?: string | undefined;
     os?: string | undefined;
 }
 export declare function runMobileRegister(options: MobileRegisterCmdOptions, deps?: ClientDeps, exec?: ExecFn): Promise<Envelope<MobileRegisterResult>>;
@@ -17,13 +18,17 @@ declare const _default: import("citty").CommandDef<{
     };
     readonly platform: {
         readonly type: "string";
-        readonly description: "Device platform (only `android` is supported today)";
+        readonly description: "Device platform (`android` or `ios`)";
         readonly default: "android";
     };
     readonly serial: {
         readonly type: "string";
         readonly description: "Android adb serial (defaults to the connected one)";
     };
+    readonly udid: {
+        readonly type: "string";
+        readonly description: "iOS device udid (defaults to the connected one)";
+    };
     readonly os: {
         readonly type: "string";
         readonly description: "Optional OS version label";

package/dist/commands/mobile/register.js

@@ -1,19 +1,23 @@
 import { defineCommand } from "citty";
 import {} from "../../client.js";
 import { formatError, printResult } from "../../output.js";
-import { resolveAndroidSerial } from "../../mobile-control/devices.js";
+import { resolveAndroidSerial, resolveIosUdid } from "../../mobile-control/devices.js";
 import { parsePlatformArg, registerMobileDevice, } from "./register-core.js";
 export async function runMobileRegister(options, deps, exec) {
     const platform = parsePlatformArg(options.platform);
-    if (platform !== "android") {
-        return formatError("validation_error", "Only --platform android is supported (iOS local devices are coming in a future release).", false);
+    if (!platform) {
+        return formatError("validation_error", "Invalid --platform; expected `android` or `ios`.", false);
     }
     if (!options.name) {
         return formatError("validation_error", "Device name is required (--name).", false);
     }
+    // Resolve the device target: an adb serial for Android, a udid for iOS.
     let target;
     try {
-        target = await resolveAndroidSerial(options.serial, exec);
+        target =
+            platform === "ios"
+                ? await resolveIosUdid(options.udid, exec)
+                : await resolveAndroidSerial(options.serial, exec);
     }
     catch (err) {
         return formatError("validation_error", err instanceof Error ? err.message : String(err), false);
@@ -28,16 +32,17 @@ export async function runMobileRegister(options, deps, exec) {
 export default defineCommand({
     meta: {
         name: "register",
-        description: "Register a physically-connected Android phone as an Aximo device",
+        description: "Register a physically-connected Android phone or iPhone as an Aximo device",
     },
     args: {
         name: { type: "string", description: "Device name", required: true },
         platform: {
             type: "string",
-            description: "Device platform (only `android` is supported today)",
+            description: "Device platform (`android` or `ios`)",
             default: "android",
         },
         serial: { type: "string", description: "Android adb serial (defaults to the connected one)" },
+        udid: { type: "string", description: "iOS device udid (defaults to the connected one)" },
         os: { type: "string", description: "Optional OS version label" },
     },
     async run({ args }) {
@@ -45,6 +50,7 @@ export default defineCommand({
             name: args.name,
             platform: args.platform,
             serial: args.serial,
+            udid: args.udid,
             os: args.os,
         }));
     },

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

@@ -26,6 +26,20 @@ const oneAndroidDevice = async () => ({
     stdout: Buffer.from("List of devices attached\nR58M12345  device model:Pixel_7\n"),
     stderr: "",
 });
+const oneIosDevice = async (file, args) => {
+    if (file === "idb" && args[0] === "list-targets") {
+        return {
+            stdout: Buffer.from(`${JSON.stringify({
+                udid: "00008030-ABCDEF",
+                name: "Abdul's iPhone",
+                type: "device",
+                state: "connected",
+            })}\n`),
+            stderr: "",
+        };
+    }
+    throw new Error(`unexpected exec: ${file} ${args.join(" ")}`);
+};
 describe("runMobileRegister", () => {
     it("posts the resolved android serial and writes config", async () => {
         let body;
@@ -49,12 +63,29 @@ describe("runMobileRegister", () => {
         expect(saved).toMatchObject({ platform: "android", target: "R58M12345" });
         expect(saved).not.toHaveProperty("category");
     });
-    it("rejects iOS registration as unsupported", async () => {
-        const result = await runMobileRegister({ name: "iPhone", platform: "ios" });
+    it("posts the resolved iOS udid and writes config", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/devices/register`, async ({ request }) => {
+            body = (await request.json());
+            return HttpResponse.json({ deviceId: "dev-ios", deviceToken: "tok-ios" }, { status: 201 });
+        }));
+        const result = await runMobileRegister({ name: "iPhone", platform: "ios" }, undefined, oneIosDevice);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(body).toMatchObject({ name: "iPhone", platform: "ios" });
+        expect(result.data.target).toBe("00008030-ABCDEF");
+        const configPath = join(tempHome, "mobile-devices", "dev-ios.json");
+        expect(existsSync(configPath)).toBe(true);
+        const saved = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(saved).toMatchObject({ platform: "ios", target: "00008030-ABCDEF" });
+    });
+    it("rejects an unknown platform", async () => {
+        const result = await runMobileRegister({ name: "x", platform: "windows" });
         expect(result.ok).toBe(false);
         if (!result.ok) {
             expect(result.error.code).toBe("validation_error");
-            expect(result.error.message).toContain("Only --platform android is supported");
+            expect(result.error.message).toContain("Invalid --platform");
         }
     });
 });

package/dist/commands/mobile/unregister.js

@@ -12,15 +12,20 @@ export async function runMobileUnregister(options, deps) {
     const { deviceId } = resolved.config;
     try {
         await request(`/api/devices/user/${deviceId}`, { method: "DELETE" }, deps ?? {});
-        const configPath = getMobileDeviceConfigPath(deviceId);
-        if (existsSync(configPath)) {
-            unlinkSync(configPath);
-        }
-        return formatSuccess({ success: true });
     }
     catch (err) {
-        return handleApiError(err);
+        // 404 = the server row is already gone (deleted via the web UI). Still clear
+        // the local config, otherwise the device can never be unregistered locally.
+        const status = err.status;
+        if (status !== 404) {
+            return handleApiError(err);
+        }
+    }
+    const configPath = getMobileDeviceConfigPath(deviceId);
+    if (existsSync(configPath)) {
+        unlinkSync(configPath);
     }
+    return formatSuccess({ success: true });
 }
 export default defineCommand({
     meta: { name: "unregister", description: "Unregister a local mobile device" },