@autifyhq/aximo-cli 0.4.0 → 0.6.0

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

@@ -0,0 +1,14 @@
+import { type ClientDeps } from "../../client.js";
+import type { Envelope } from "../../types.js";
+export declare function runMobileUnregister(options: {
+    deviceId?: string;
+}, deps?: ClientDeps): Promise<Envelope<{
+    success: boolean;
+}>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "device-id": {
+        readonly type: "string";
+        readonly description: "Device ID (defaults to the sole registered local device)";
+    };
+}>;
+export default _default;

package/dist/commands/mobile/unregister.js

@@ -0,0 +1,37 @@
+import { defineCommand } from "citty";
+import { existsSync, unlinkSync } from "node:fs";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { formatSuccess, printResult } from "../../output.js";
+import { resolveDeviceConfig } from "./connect-core.js";
+import { getMobileDeviceConfigPath } from "./paths.js";
+export async function runMobileUnregister(options, deps) {
+    const resolved = resolveDeviceConfig(options.deviceId);
+    if (!resolved.ok)
+        return resolved;
+    const { deviceId } = resolved.config;
+    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);
+    }
+}
+export default defineCommand({
+    meta: { name: "unregister", description: "Unregister a local mobile device" },
+    args: {
+        "device-id": {
+            type: "string",
+            description: "Device ID (defaults to the sole registered local device)",
+        },
+    },
+    async run({ args }) {
+        const deviceId = args["device-id"];
+        printResult(await runMobileUnregister(deviceId ? { deviceId } : {}));
+    },
+});

package/dist/commands/schema.js

@@ -36,6 +36,7 @@ export function getSchema() {
                     arg("upload-type", "string", "ANDROID_APP | IOS_APP"),
                     arg("app-name", "string", ""),
                     arg("bundle-id", "string", ""),
+                    arg("user-device-id", "string", "Run on a registered local device"),
                     ...MUTATE_ARGS,
                 ]),
                 cmd("get", "GET /api/sessions/{sessionId}", [
@@ -119,6 +120,34 @@ export function getSchema() {
                     arg("available-only", "boolean", ""),
                 ]),
             ]),
+            cmd("mobile", "Register and connect a physically-connected Android phone (adb) or iPhone (idb/Xcode)", [], [
+                cmd("list", "List physically-connected phones (Android via adb, iOS via idb)"),
+                cmd("register", "Register a physically-connected Android phone or iPhone as an Aximo device", [
+                    arg("name", "string", "Device name", true),
+                    arg("platform", "string", "Device platform (`android` or `ios`)"),
+                    arg("serial", "string", "Android adb serial (defaults to the connected one)"),
+                    arg("udid", "string", "iOS device udid (defaults to the connected one)"),
+                    arg("os", "string", "Optional OS version label"),
+                ]),
+                cmd("install", "Install an app on the connected phone (.apk via adb, .ipa via idb)", [
+                    arg("app", "string", "Path to the .apk or .ipa to install", true),
+                    arg("platform", "string", "android | ios (inferred from the file extension)"),
+                    arg("serial", "string", "Android adb serial (defaults to the connected one)"),
+                    arg("udid", "string", "iOS device udid (defaults to the connected one)"),
+                ]),
+                cmd("unregister", "Unregister a local mobile device", [
+                    arg("device-id", "string", "Device ID (defaults to the sole registered local device)"),
+                ]),
+                cmd("connect", "Connect a registered phone via a CLI-managed Appium server", [
+                    arg("device-id", "string", "Registered device id (required if multiple)"),
+                ]),
+                cmd("setup", "Install the Appium drivers used to drive registered phones", [
+                    arg("platform", "string", "Limit to ios | android driver"),
+                ]),
+                cmd("doctor", "Diagnose physical-device tooling (adb/idb, Xcode, Appium setup)", [
+                    arg("platform", "string", "Limit checks to ios | android"),
+                ]),
+            ]),
             cmd("upload", "Upload commands", [], [
                 cmd("create", "POST /api/uploads", [
                     arg("file-name", "string", "File name"),

package/dist/commands/session/create.d.ts

@@ -16,6 +16,7 @@ export interface CreateSessionOptions {
     uploadType?: unknown;
     appName?: unknown;
     bundleId?: unknown;
+    userDeviceId?: unknown;
     json?: unknown;
     dryRun?: unknown;
 }
@@ -66,6 +67,10 @@ declare const _default: import("citty").CommandDef<{
     readonly "bundle-id": {
         readonly type: "string";
     };
+    readonly "user-device-id": {
+        readonly type: "string";
+        readonly description: "Run on a registered local device (BYOD desktop or local mobile)";
+    };
     readonly json: {
         readonly type: "string";
         readonly description: "Raw JSON request body (replaces individual flags)";

package/dist/commands/session/create.js

@@ -29,6 +29,7 @@ export async function runSessionCreate(options, deps) {
                 uploadType: parseFileType(options.uploadType),
                 appName: optionalString("appName", options.appName),
                 bundleId: optionalString("bundleId", options.bundleId),
+                userDeviceId: optionalString("userDeviceId", options.userDeviceId),
             };
         }
         catch (err) {
@@ -63,6 +64,10 @@ export default defineCommand({
         "upload-type": { type: "string", description: "ANDROID_APP | IOS_APP" },
         "app-name": { type: "string" },
         "bundle-id": { type: "string" },
+        "user-device-id": {
+            type: "string",
+            description: "Run on a registered local device (BYOD desktop or local mobile)",
+        },
         json: { type: "string", description: "Raw JSON request body (replaces individual flags)" },
         "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
     },
@@ -82,6 +87,7 @@ export default defineCommand({
             uploadType: args["upload-type"],
             appName: args["app-name"],
             bundleId: args["bundle-id"],
+            userDeviceId: args["user-device-id"],
             json: args.json,
             dryRun: args["dry-run"],
         }));

package/dist/index.d.ts

@@ -3,6 +3,9 @@ export { getApiKey, getBaseUrl, request } from "./client.js";
 export { runCaseCreate } from "./commands/case/create.js";
 export { runDeviceList } from "./commands/device/list.js";
 export { runHealthCheck } from "./commands/health/check.js";
+export { runMobileList } from "./commands/mobile/list.js";
+export { runMobileRegister } from "./commands/mobile/register.js";
+export { runMobileDoctor } from "./commands/mobile/doctor.js";
 export { runPlanAddCase } from "./commands/plan/add-case.js";
 export { runPlanCreate } from "./commands/plan/create.js";
 export { runPlanRemoveCase } from "./commands/plan/remove-case.js";

package/dist/index.js

@@ -2,6 +2,9 @@ export { getApiKey, getBaseUrl, request } from "./client.js";
 export { runCaseCreate } from "./commands/case/create.js";
 export { runDeviceList } from "./commands/device/list.js";
 export { runHealthCheck } from "./commands/health/check.js";
+export { runMobileList } from "./commands/mobile/list.js";
+export { runMobileRegister } from "./commands/mobile/register.js";
+export { runMobileDoctor } from "./commands/mobile/doctor.js";
 export { runPlanAddCase } from "./commands/plan/add-case.js";
 export { runPlanCreate } from "./commands/plan/create.js";
 export { runPlanRemoveCase } from "./commands/plan/remove-case.js";

package/dist/mobile-control/app-install.d.ts

@@ -0,0 +1,21 @@
+import { type ClientDeps } from "../client.js";
+import { type ExecFn } from "./exec.js";
+export interface InstallUploadedAppOptions {
+    /** Aximo upload id of the app under test. */
+    uploadId: string;
+    platform: "ios" | "android";
+    /** adb serial (Android) or udid (iOS) of the registered device. */
+    target: string;
+    exec?: ExecFn;
+    /** Client overrides (apiKey/baseUrl/fetchImpl) — used in tests. */
+    deps?: ClientDeps;
+}
+/**
+ * Download the app under test from Aximo (authenticated via the org API key, which
+ * redirects to short-lived storage) and install it on the connected device —
+ * Android `.apk` via `adb install -r`, iOS `.ipa` via `idb install`. The app binary
+ * never crosses the control tunnel; only the opaque upload id does.
+ */
+export declare function installUploadedApp(opts: InstallUploadedAppOptions): Promise<{
+    output: string;
+}>;

package/dist/mobile-control/app-install.js

@@ -0,0 +1,28 @@
+import { randomBytes } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { requestToFile } from "../client.js";
+import { execBinary } from "./exec.js";
+/**
+ * Download the app under test from Aximo (authenticated via the org API key, which
+ * redirects to short-lived storage) and install it on the connected device —
+ * Android `.apk` via `adb install -r`, iOS `.ipa` via `idb install`. The app binary
+ * never crosses the control tunnel; only the opaque upload id does.
+ */
+export async function installUploadedApp(opts) {
+    const exec = opts.exec ?? execBinary;
+    const ext = opts.platform === "ios" ? ".ipa" : ".apk";
+    const tmpPath = join(tmpdir(), `aximo-install-${randomBytes(8).toString("hex")}${ext}`);
+    try {
+        // Stream the (authenticated) download straight to disk — apps can be large.
+        await requestToFile(`/api/devices/apps/${encodeURIComponent(opts.uploadId)}/download`, tmpPath, opts.deps ?? {});
+        const { stdout } = opts.platform === "ios"
+            ? await exec("idb", ["install", "--udid", opts.target, tmpPath])
+            : await exec("adb", ["-s", opts.target, "install", "-r", tmpPath]);
+        return { output: stdout.toString("utf-8").trim() };
+    }
+    finally {
+        await rm(tmpPath, { force: true }).catch(() => { });
+    }
+}

package/dist/mobile-control/app-install.test.d.ts

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

package/dist/mobile-control/app-install.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from "vitest";
+import { installUploadedApp } from "./app-install.js";
+const DEPS = { apiKey: "test-key", baseUrl: "https://aximo.test" };
+function fakeFetch(ok, bytes = "apk-bytes") {
+    let seen = "";
+    const impl = vi.fn(async (url) => {
+        seen = url;
+        return {
+            ok,
+            status: ok ? 200 : 403,
+            statusText: ok ? "OK" : "Forbidden",
+            text: async () => (ok ? "" : "forbidden"),
+            body: ok
+                ? new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(new TextEncoder().encode(bytes));
+                        controller.close();
+                    },
+                })
+                : null,
+            headers: { get: () => null },
+        };
+    });
+    return { impl, url: () => seen };
+}
+function captureExec() {
+    const calls = [];
+    const exec = async (file, args) => {
+        calls.push({ file, args });
+        return { stdout: Buffer.from("Success"), stderr: "" };
+    };
+    return { exec, calls: () => calls };
+}
+describe("installUploadedApp", () => {
+    it("fetches the app authenticated by upload id and installs via adb", async () => {
+        const { exec, calls } = captureExec();
+        const { impl, url } = fakeFetch(true);
+        const res = await installUploadedApp({
+            uploadId: "up-123",
+            platform: "android",
+            target: "R1",
+            exec,
+            deps: { ...DEPS, fetchImpl: impl },
+        });
+        expect(res.output).toContain("Success");
+        expect(url()).toBe("https://aximo.test/api/devices/apps/up-123/download");
+        const call = calls()[0];
+        expect(call?.file).toBe("adb");
+        expect(call?.args.slice(0, 4)).toEqual(["-s", "R1", "install", "-r"]);
+        expect(call?.args[4]).toMatch(/\.apk$/);
+    });
+    it("installs an iOS app via idb", async () => {
+        const { exec, calls } = captureExec();
+        const { impl } = fakeFetch(true);
+        await installUploadedApp({
+            uploadId: "up-9",
+            platform: "ios",
+            target: "00008030-ABC",
+            exec,
+            deps: { ...DEPS, fetchImpl: impl },
+        });
+        const call = calls()[0];
+        expect(call?.file).toBe("idb");
+        expect(call?.args.slice(0, 3)).toEqual(["install", "--udid", "00008030-ABC"]);
+        expect(call?.args[3]).toMatch(/\.ipa$/);
+    });
+    it("throws when the authenticated download fails", async () => {
+        const { exec } = captureExec();
+        const { impl } = fakeFetch(false);
+        await expect(installUploadedApp({
+            uploadId: "missing",
+            platform: "android",
+            target: "R1",
+            exec,
+            deps: { ...DEPS, fetchImpl: impl },
+        })).rejects.toThrow();
+    });
+});

package/dist/mobile-control/appium-controller.d.ts

@@ -0,0 +1,42 @@
+import type { ActionResult, MobileController } from "./controller.js";
+import { type IosSigningConfig } from "./ios-signing.js";
+import { type WebDriverTransport } from "./webdriver.js";
+export interface AppiumControllerOptions {
+    endpoint: string;
+    platform: "ios" | "android";
+    target: string;
+    iosSigning?: IosSigningConfig;
+    transport?: WebDriverTransport;
+}
+export declare class AppiumController implements MobileController {
+    private readonly session;
+    private readonly platform;
+    private readonly target;
+    private readonly iosSigning;
+    private sessionReady;
+    private scaling;
+    constructor(opts: AppiumControllerOptions);
+    private capabilities;
+    private ensureSession;
+    private scale;
+    private toPoint;
+    private pointerAction;
+    screenshot(): Promise<Buffer>;
+    tap(x: number, y: number): Promise<void>;
+    doubleTap(x: number, y: number): Promise<void>;
+    longPress(x: number, y: number, durationMs: number): Promise<void>;
+    swipe(x1: number, y1: number, x2: number, y2: number, durationMs: number): Promise<void>;
+    private performPointer;
+    typeText(text: string): Promise<ActionResult>;
+    clearText(): Promise<ActionResult>;
+    pressKey(key: string): Promise<ActionResult>;
+    launchApp(app: string): Promise<ActionResult>;
+    findElement(text: string): Promise<ActionResult>;
+    private locate;
+    hideKeyboard(): Promise<ActionResult>;
+    getDeviceTime(): Promise<{
+        datetime: string;
+        timezone: string;
+    } | null>;
+    close(): Promise<void>;
+}