@autifyhq/aximo-cli 0.4.0 → 0.6.0

package/dist/commands/device/unregister.test.js

@@ -0,0 +1,73 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { runDeviceUnregister } from "./unregister.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-unregister-"));
+    process.env["AXIMO_HOME"] = tempHome;
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    process.env["AXIMO_API_KEY"] = "test-key";
+    server.listen();
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    delete process.env["AXIMO_BASE_URL"];
+    delete process.env["AXIMO_API_KEY"];
+    server.close();
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+afterEach(() => server.resetHandlers());
+function devicePath() {
+    return join(tempHome, "device.json");
+}
+function seedDevice(cfg) {
+    writeFileSync(devicePath(), JSON.stringify(cfg), { mode: 0o600 });
+}
+describe("runDeviceUnregister", () => {
+    it("deletes the server device and removes the local file", async () => {
+        seedDevice({ deviceId: "dev-1", deviceToken: "t", name: "x" });
+        server.use(http.delete(`${TEST_BASE_URL}/api/devices/user/dev-1`, () => HttpResponse.json({ success: true })));
+        const result = await runDeviceUnregister({});
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.serverDeleted).toBe(true);
+        expect(existsSync(devicePath())).toBe(false);
+    });
+    it("clears the local file even when the server returns 404", async () => {
+        seedDevice({ deviceId: "dev-gone", deviceToken: "t", name: "x" });
+        server.use(http.delete(`${TEST_BASE_URL}/api/devices/user/dev-gone`, () => HttpResponse.json({ error: "not found" }, { status: 404 })));
+        const result = await runDeviceUnregister({});
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.serverDeleted).toBe(false);
+        expect(existsSync(devicePath())).toBe(false);
+    });
+    it("keeps the local file and errors on a non-404 server error", async () => {
+        seedDevice({ deviceId: "dev-1", deviceToken: "t", name: "x" });
+        server.use(http.delete(`${TEST_BASE_URL}/api/devices/user/dev-1`, () => HttpResponse.json({ error: "boom" }, { status: 500 })));
+        const result = await runDeviceUnregister({});
+        expect(result.ok).toBe(false);
+        expect(existsSync(devicePath())).toBe(true);
+    });
+    it("errors when no device id is given and no local config exists", async () => {
+        const result = await runDeviceUnregister({});
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("uses an explicit device id without removing a differing local file", async () => {
+        seedDevice({ deviceId: "local-1", deviceToken: "t", name: "x" });
+        server.use(http.delete(`${TEST_BASE_URL}/api/devices/user/other-2`, () => HttpResponse.json({ success: true })));
+        const result = await runDeviceUnregister({ deviceId: "other-2" });
+        expect(result.ok).toBe(true);
+        // The local registration is for a different device, so it stays.
+        expect(existsSync(devicePath())).toBe(true);
+    });
+});

package/dist/commands/mobile/connect-core.d.ts

@@ -0,0 +1,12 @@
+import type { ErrorEnvelope } from "../../types.js";
+import type { MobileController } from "../../mobile-control/controller.js";
+import { type MobileDeviceConfig } from "./paths.js";
+export declare function getTunnelOrigin(): string;
+interface ConfigOk {
+    ok: true;
+    config: MobileDeviceConfig;
+}
+export declare function resolveDeviceConfig(deviceId: string | undefined): ConfigOk | ErrorEnvelope;
+export declare function buildController(config: MobileDeviceConfig, endpoint: string): MobileController;
+export declare function connectWithConfig(config: MobileDeviceConfig): Promise<void>;
+export {};

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

@@ -0,0 +1,88 @@
+import { getBaseUrl } from "../../client.js";
+import { formatError } from "../../output.js";
+import { AppiumController } from "../../mobile-control/appium-controller.js";
+import { installUploadedApp } from "../../mobile-control/app-install.js";
+import { startAppiumServer } from "../../mobile-control/appium-server.js";
+import { resolveIosSigning } from "../../mobile-control/ios-signing.js";
+import { runControlTunnel } from "../../mobile-control/tunnel.js";
+import { runMobileDoctor } from "./doctor.js";
+import { listMobileDeviceConfigs, readMobileDeviceConfig, } from "./paths.js";
+export function getTunnelOrigin() {
+    return getBaseUrl().replace(/^http/, "ws");
+}
+export function resolveDeviceConfig(deviceId) {
+    if (deviceId) {
+        const config = readMobileDeviceConfig(deviceId);
+        if (!config) {
+            return formatError("not_found", `No registered device with id '${deviceId}'.`, false);
+        }
+        return { ok: true, config };
+    }
+    const all = listMobileDeviceConfigs();
+    if (all.length === 0) {
+        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 only = all[0];
+    if (!only) {
+        return formatError("validation_error", "No registered devices.", false);
+    }
+    return { ok: true, config: only };
+}
+export function buildController(config, endpoint) {
+    return new AppiumController({
+        endpoint,
+        platform: config.platform,
+        target: config.target,
+        ...(config.platform === "ios" ? { iosSigning: resolveIosSigning() } : {}),
+    });
+}
+// A blocking check is any hard failure, plus a missing automation driver
+// (only a warning for `doctor`, but a hard prerequisite for connecting).
+function isBlockingCheck(check, driverName) {
+    if (check.status === "fail")
+        return true;
+    return check.name === driverName && check.status === "warn";
+}
+async function assertPrerequisites(platform) {
+    const driverName = platform === "ios" ? "xcuitest driver" : "uiautomator2 driver";
+    const report = await runMobileDoctor({ platform });
+    const checks = report.ok ? report.data.checks : [];
+    const blockers = checks.filter((c) => isBlockingCheck(c, driverName));
+    if (blockers.length === 0)
+        return;
+    const lines = blockers.map((c) => `  - ${c.message}${c.hint ? `\n      ${c.hint}` : ""}`);
+    const setup = platform === "ios" ? "aximo mobile setup --platform ios" : "aximo mobile setup";
+    const doctor = platform === "ios" ? "aximo mobile doctor --platform ios" : "aximo mobile doctor";
+    throw new Error(`Missing ${platform} prerequisites:\n${lines.join("\n")}\n` +
+        `Run \`${setup}\` and/or fix the above, then re-run. (\`${doctor}\` for details.)`);
+}
+export async function connectWithConfig(config) {
+    await assertPrerequisites(config.platform);
+    const useDrivers = config.platform === "ios" ? ["xcuitest"] : ["uiautomator2"];
+    const server = await startAppiumServer({ useDrivers });
+    const controller = buildController(config, server.endpoint);
+    try {
+        await runControlTunnel({
+            wsUrl: getTunnelOrigin(),
+            deviceToken: config.deviceToken,
+            deviceName: config.name,
+            controller,
+            installApp: async ({ uploadId }) => {
+                await installUploadedApp({
+                    uploadId,
+                    platform: config.platform,
+                    target: config.target,
+                });
+            },
+        });
+    }
+    finally {
+        await controller.close();
+        await server.stop();
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { MobileDeviceConfig } from "./paths.js";
+export declare function iosPhysicalWarning(config: MobileDeviceConfig): string | null;
+declare const _default: import("citty").CommandDef<{
+    readonly "device-id": {
+        readonly type: "string";
+        readonly description: "Registered device id (required if multiple)";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/connect.js

@@ -0,0 +1,35 @@
+import { defineCommand } from "citty";
+import { formatError, printResult } from "../../output.js";
+import { connectWithConfig, resolveDeviceConfig } from "./connect-core.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 " +
+    "signing identity; if control fails, run `aximo mobile doctor` for guidance.";
+export function iosPhysicalWarning(config) {
+    return config.platform === "ios" ? IOS_PHYSICAL_WARNING : null;
+}
+export default defineCommand({
+    meta: {
+        name: "connect",
+        description: "Connect a registered phone to Aximo via a CLI-managed Appium server",
+    },
+    args: {
+        "device-id": { type: "string", description: "Registered device id (required if multiple)" },
+    },
+    async run({ args }) {
+        const resolved = resolveDeviceConfig(args["device-id"]);
+        if (!resolved.ok) {
+            printResult(resolved);
+            return;
+        }
+        const warning = iosPhysicalWarning(resolved.config);
+        if (warning)
+            console.error(warning);
+        try {
+            await connectWithConfig(resolved.config);
+        }
+        catch (error) {
+            printResult(formatError("api_error", error instanceof Error ? error.message : String(error), true));
+        }
+    },
+});

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

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

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

@@ -0,0 +1,87 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveDeviceConfig } from "./connect-core.js";
+import { iosPhysicalWarning } from "./connect.js";
+import { writeMobileDeviceConfig } from "./paths.js";
+let tempHome;
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-mob-connect-"));
+    process.env["AXIMO_HOME"] = tempHome;
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+describe("iosPhysicalWarning", () => {
+    it("returns an Appium/WDA guidance warning for iOS configs", () => {
+        const warning = iosPhysicalWarning({
+            deviceId: "d1",
+            deviceToken: "t",
+            name: "iPhone",
+            platform: "ios",
+            target: "udid",
+        });
+        expect(warning).toContain("WebDriverAgent");
+        expect(warning).toContain("Developer Mode");
+    });
+    it("returns null for android configs (no warning)", () => {
+        const warning = iosPhysicalWarning({
+            deviceId: "d2",
+            deviceToken: "t",
+            name: "Pixel",
+            platform: "android",
+            target: "serial",
+        });
+        expect(warning).toBeNull();
+    });
+});
+describe("resolveDeviceConfig", () => {
+    it("returns validation_error when none are registered", () => {
+        const result = resolveDeviceConfig(undefined);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("auto-selects the only registered device", () => {
+        writeMobileDeviceConfig({
+            deviceId: "only-1",
+            deviceToken: "t",
+            name: "Solo",
+            platform: "android",
+            target: "serial-1",
+        });
+        const result = resolveDeviceConfig(undefined);
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.config.deviceId).toBe("only-1");
+    });
+    it("requires --device-id when multiple are registered", () => {
+        for (const id of ["a", "b"]) {
+            writeMobileDeviceConfig({
+                deviceId: id,
+                deviceToken: "t",
+                name: id,
+                platform: "android",
+                target: `serial-${id}`,
+            });
+        }
+        const ambiguous = resolveDeviceConfig(undefined);
+        expect(ambiguous.ok).toBe(false);
+        const picked = resolveDeviceConfig("b");
+        expect(picked.ok).toBe(true);
+        if (picked.ok)
+            expect(picked.config.deviceId).toBe("b");
+    });
+    it("returns not_found for an unknown device id", () => {
+        const result = resolveDeviceConfig("ghost");
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+});

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

@@ -0,0 +1,28 @@
+import type { Envelope } from "../../types.js";
+export type CheckStatus = "pass" | "warn" | "fail" | "info";
+export interface Check {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    hint?: string;
+}
+export interface MobileDoctorReport {
+    checks: Check[];
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+        info: number;
+    };
+}
+export interface RunMobileDoctorOptions {
+    platform?: "ios" | "android" | undefined;
+}
+export declare function runMobileDoctor(options?: RunMobileDoctorOptions): Promise<Envelope<MobileDoctorReport>>;
+declare const _default: import("citty").CommandDef<{
+    readonly platform: {
+        readonly type: "string";
+        readonly description: "Limit checks to ios | android";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/doctor.js

@@ -0,0 +1,162 @@
+import { defineCommand } from "citty";
+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 { importAppium } from "../../mobile-control/appium-import.js";
+import { getAppiumHome, resolveAndroidSdk } from "../../mobile-control/appium-server.js";
+import { resolveIosSigning } from "../../mobile-control/ios-signing.js";
+function which(cmd) {
+    const probe = platform() === "win32" ? "where" : "which";
+    const result = spawnSync(probe, [cmd], { encoding: "utf-8" });
+    return result.status === 0 ? (result.stdout || "").split("\n")[0]?.trim() || cmd : null;
+}
+function driverInstalled(driver) {
+    return existsSync(join(getAppiumHome(), "node_modules", `appium-${driver}-driver`));
+}
+function adbInstallHint() {
+    switch (platform()) {
+        case "darwin":
+            return "Install Android platform-tools (brew install --cask android-platform-tools).";
+        case "linux":
+            return "Install Android platform-tools (apt install android-tools-adb, or your distro's adb package).";
+        case "win32":
+            return "Install platform-tools via the Android Studio SDK Manager.";
+        default:
+            return "Install Android platform-tools (adb).";
+    }
+}
+async function checkAppium() {
+    try {
+        const mod = await importAppium();
+        if (typeof mod.main === "function") {
+            return { name: "appium", status: "pass", message: "bundled Appium server is importable" };
+        }
+        return {
+            name: "appium",
+            status: "fail",
+            message: "appium is installed but exposes no programmatic `main`",
+        };
+    }
+    catch (err) {
+        return {
+            name: "appium",
+            status: "fail",
+            message: err instanceof Error ? err.message : String(err),
+            hint: "Reinstall the CLI; the bundled Appium dependency appears to be missing.",
+        };
+    }
+}
+function checkAndroid() {
+    const checks = [];
+    checks.push(driverInstalled("uiautomator2")
+        ? { name: "uiautomator2 driver", status: "pass", message: "installed" }
+        : {
+            name: "uiautomator2 driver",
+            status: "warn",
+            message: "Appium UiAutomator2 driver not installed",
+            hint: "Run `aximo mobile setup` to install Appium drivers.",
+        });
+    const adb = which("adb");
+    checks.push(adb
+        ? { name: "adb", status: "pass", message: adb }
+        : {
+            name: "adb",
+            status: "fail",
+            message: "adb not found in PATH",
+            hint: `${adbInstallHint()} Appium delegates to adb.`,
+        });
+    const sdk = resolveAndroidSdk();
+    checks.push(sdk
+        ? { name: "android sdk", status: "pass", message: sdk }
+        : {
+            name: "android sdk",
+            status: "fail",
+            message: "Android SDK not found (ANDROID_HOME/ANDROID_SDK_ROOT unset)",
+            hint: "Set ANDROID_HOME to your Android SDK — Appium's UiAutomator2 driver requires it even though adb is on PATH — or install it via Android Studio.",
+        });
+    return checks;
+}
+function checkIos() {
+    if (platform() !== "darwin") {
+        return [
+            { name: "ios", status: "info", message: "iOS device control is only available on macOS" },
+        ];
+    }
+    const checks = [];
+    checks.push(driverInstalled("xcuitest")
+        ? { name: "xcuitest driver", status: "pass", message: "installed" }
+        : {
+            name: "xcuitest driver",
+            status: "warn",
+            message: "Appium XCUITest driver not installed",
+            hint: "Run `aximo mobile setup` to install Appium drivers.",
+        });
+    const xcrun = which("xcrun");
+    checks.push(xcrun
+        ? { name: "xcrun", status: "pass", message: xcrun }
+        : {
+            name: "xcrun",
+            status: "fail",
+            message: "xcrun not found",
+            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: "pass", 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.",
+        });
+    const teamId = resolveIosSigning().teamId;
+    checks.push(teamId
+        ? { name: "ios signing", status: "pass", message: `signing team id is set (${teamId})` }
+        : {
+            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.",
+        });
+    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.",
+    });
+    return checks;
+}
+export async function runMobileDoctor(options = {}) {
+    const checks = [await checkAppium()];
+    if (options.platform !== "ios") {
+        checks.push(...checkAndroid());
+    }
+    if (options.platform !== "android") {
+        checks.push(...checkIos());
+    }
+    const summary = { pass: 0, warn: 0, fail: 0, info: 0 };
+    for (const c of checks)
+        summary[c.status]++;
+    return formatSuccess({ checks, summary });
+}
+export default defineCommand({
+    meta: {
+        name: "doctor",
+        description: "Diagnose Appium prerequisites (bundled server, drivers, adb/Xcode delegates)",
+    },
+    args: {
+        platform: { type: "string", description: "Limit checks to ios | android" },
+    },
+    async run({ args }) {
+        const options = {};
+        if (args.platform === "ios" || args.platform === "android")
+            options.platform = args.platform;
+        const result = await runMobileDoctor(options);
+        printResult(result);
+        if (result.ok && result.data.summary.fail > 0) {
+            process.exitCode = 1;
+        }
+    },
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/mobile/index.js

@@ -0,0 +1,16 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: {
+        name: "mobile",
+        description: "Register and connect a phone to Aximo via a CLI-managed Appium server",
+    },
+    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),
+        doctor: () => import("./doctor.js").then((m) => m.default),
+    },
+});

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

@@ -0,0 +1,43 @@
+import { type ExecFn } from "../../mobile-control/exec.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;
+}
+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 `idb install`. The iOS build must be signed for the device.
+ */
+export declare function runMobileInstall(options: MobileInstallOptions, exec?: ExecFn): 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,76 @@
+import { existsSync } from "node:fs";
+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 { 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 `idb install`. The iOS build must be signed for the device.
+ */
+export async function runMobileInstall(options, exec = execBinary) {
+    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 {
+        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(),
+        });
+    }
+    catch (err) {
+        return formatError("api_error", err instanceof Error ? err.message : String(err), false);
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "install",
+        description: "Install an app on the connected phone (.apk via adb, .ipa via idb)",
+    },
+    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 {};