@autifyhq/aximo-cli 0.9.0 → 0.10.1

package/dist/mobile-control/tunnel.js

@@ -52,7 +52,7 @@ function defaultConnect(wsUrl, deviceToken) {
 // Mirrors the gateway's lock lease: a session quiet for longer than this has lost
 // its server-side lock, so a new session id is a legitimate takeover, not a stray.
 const SESSION_LEASE_MS = 25 * 60 * 1000;
-export function registerHandlers(socket, controller, installApp) {
+export function registerHandlers(socket, controller, installApp, stream) {
     // Device-side guard against interleaved sessions: the gateway announces owner
     // changes (session_acquired/session_released) and tags each command with its
     // session id, so commands from a session that no longer owns the device are
@@ -70,8 +70,22 @@ export function registerHandlers(socket, controller, installApp) {
         const sessionId = args?.sessionId;
         if (activeSession && activeSession.id === sessionId) {
             activeSession = null;
+            // No owning session -> nobody may watch the phone.
+            stream?.stop();
         }
     });
+    // Demand gating: the gateway asks for frames only while a session owns the
+    // device AND at least one viewer is reading them; it signals idle explicitly
+    // (and the frame acks carry the same signal as a backstop). The device-side
+    // owner check mirrors the command guard: a stray start from a gateway
+    // instance with stale state must not stream an idle phone. A start dropped
+    // here self-heals — the gateway re-signals while viewers keep reading, and
+    // the owner becomes known on session_acquired or the next tagged command.
+    socket.on("stream_start", () => {
+        if (activeSession)
+            stream?.start();
+    });
+    socket.on("stream_stop", () => stream?.stop());
     const on = (event, handler) => {
         socket.on(event, (rawArgs, ack) => {
             // Destructure the routing-only tag off a clone so the caller's payload
@@ -88,7 +102,13 @@ export function registerHandlers(socket, controller, installApp) {
             }
             void handler(args)
                 .then((result) => ack?.(result))
-                .catch((err) => ack?.(fail(err)));
+                .catch((err) => {
+                const failure = fail(err);
+                // The server may collapse this ack into a generic error; the terminal
+                // is the only place the device-side cause is guaranteed to be visible.
+                console.error(`Command "${event}" failed: ${failure.error}`);
+                ack?.(failure);
+            });
         });
     };
     on("ping", async () => ok());
@@ -172,7 +192,7 @@ export function registerHandlers(socket, controller, installApp) {
 export async function runControlTunnel(options) {
     const connect = options.connect ?? defaultConnect;
     const socket = connect(options.wsUrl, options.deviceToken);
-    registerHandlers(socket, options.controller, options.installApp);
+    registerHandlers(socket, options.controller, options.installApp, options.stream);
     await new Promise((resolve, reject) => {
         let shuttingDown = false;
         let serverKicks = [];
@@ -180,6 +200,7 @@ export async function runControlTunnel(options) {
             if (shuttingDown)
                 return;
             shuttingDown = true;
+            options.stream?.stop();
             socket.close();
             resolve();
         };
@@ -211,6 +232,9 @@ export async function runControlTunnel(options) {
             console.error(`Connection error: ${err.message}`);
         });
         socket.on("disconnect", (reason) => {
+            // Whatever the reason, a disconnected tunnel means no viewer can be
+            // watching — stop capture; a reconnect re-arms via stream_start.
+            options.stream?.stop();
             // A SIGINT/SIGTERM teardown closes the socket itself; cleanup() already
             // resolved the promise, so don't report our own close as an error.
             if (shuttingDown)

package/dist/mobile-control/tunnel.test.js

@@ -49,6 +49,23 @@ describe("registerHandlers", () => {
         expect(Buffer.isBuffer(result)).toBe(true);
         expect(result.equals(Buffer.from([1, 2, 3]))).toBe(true);
     });
+    it("a throwing handler acks the failure and logs it to the terminal", async () => {
+        const logSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const screenshot = vi.fn(async () => {
+                throw new Error("Hidden API policy cannot be enabled");
+            });
+            const socket = wire(stubController({ screenshot }));
+            await expect(socket.emit("screenshot", {})).resolves.toEqual({
+                ok: false,
+                error: "Hidden API policy cannot be enabled",
+            });
+            expect(logSpy).toHaveBeenCalledWith('Command "screenshot" failed: Hidden API policy cannot be enabled');
+        }
+        finally {
+            logSpy.mockRestore();
+        }
+    });
     it("tap forwards coordinates and acks ok", async () => {
         const tap = vi.fn(async () => { });
         const socket = wire(stubController({ tap }));
@@ -310,3 +327,36 @@ describe("registerHandlers session guard", () => {
         expect(tap).toHaveBeenCalledTimes(2);
     });
 });
+describe("stream lifecycle handlers", () => {
+    function wireWithStream() {
+        const socket = new FakeSocket();
+        const stream = { start: vi.fn(), stop: vi.fn() };
+        registerHandlers(socket, stubController(), undefined, stream);
+        return { socket, stream };
+    }
+    it("starts and stops capture on gateway demand signals while a session owns the device", () => {
+        const { socket, stream } = wireWithStream();
+        socket.handlers.get("session_acquired")?.({ sessionId: "s1" }, undefined);
+        socket.handlers.get("stream_start")?.({}, undefined);
+        expect(stream.start).toHaveBeenCalledTimes(1);
+        socket.handlers.get("stream_stop")?.({}, undefined);
+        expect(stream.stop).toHaveBeenCalledTimes(1);
+    });
+    it("drops stream_start when no session owns the device", () => {
+        const { socket, stream } = wireWithStream();
+        socket.handlers.get("stream_start")?.({}, undefined);
+        expect(stream.start).not.toHaveBeenCalled();
+    });
+    it("stops capture when the owning session releases the device", () => {
+        const { socket, stream } = wireWithStream();
+        socket.handlers.get("session_acquired")?.({ sessionId: "s1" }, undefined);
+        socket.handlers.get("session_released")?.({ sessionId: "s1" }, undefined);
+        expect(stream.stop).toHaveBeenCalledTimes(1);
+    });
+    it("ignores a release from a session that does not own the device", () => {
+        const { socket, stream } = wireWithStream();
+        socket.handlers.get("session_acquired")?.({ sessionId: "s1" }, undefined);
+        socket.handlers.get("session_released")?.({ sessionId: "other" }, undefined);
+        expect(stream.stop).not.toHaveBeenCalled();
+    });
+});

package/dist/mobile-control/webdriver.d.ts

@@ -33,5 +33,7 @@ export declare class WebDriverSession {
     elementSendKeys(elementRef: string, text: string): Promise<void>;
     elementDisplayed(elementRef: string): Promise<boolean>;
     execute(script: string, args?: unknown[]): Promise<unknown>;
+    /** Appium extension endpoint: update driver settings for the current session. */
+    updateSettings(settings: Record<string, unknown>): Promise<void>;
 }
 export declare const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";

package/dist/mobile-control/webdriver.js

@@ -128,6 +128,12 @@ export class WebDriverSession {
             args,
         });
     }
+    /** Appium extension endpoint: update driver settings for the current session. */
+    async updateSettings(settings) {
+        await this.transport.request("POST", `/session/${this.requireId()}/appium/settings`, {
+            settings,
+        });
+    }
 }
 export const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
 function elementId(value) {

package/dist/prompt.d.ts

@@ -0,0 +1,11 @@
+export interface ConfirmOptions {
+    /** Whether a human can answer; defaults to stdin being a TTY. */
+    interactive?: boolean;
+    ask?: (question: string) => Promise<string>;
+}
+/**
+ * Yes-by-default confirmation. Enter proceeds; only an explicit n/no declines.
+ * Unattended callers (no TTY) proceed without asking, so CI and daemonized
+ * devices keep working instead of hanging on a prompt nobody can see.
+ */
+export declare function confirmYesNo(question: string, options?: ConfirmOptions): Promise<boolean>;

package/dist/prompt.js

@@ -0,0 +1,19 @@
+import { createInterface } from "node:readline/promises";
+function defaultAsk(question) {
+    // stderr, so prompts never contaminate the JSON envelope on stdout.
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return rl.question(question).finally(() => rl.close());
+}
+/**
+ * Yes-by-default confirmation. Enter proceeds; only an explicit n/no declines.
+ * Unattended callers (no TTY) proceed without asking, so CI and daemonized
+ * devices keep working instead of hanging on a prompt nobody can see.
+ */
+export async function confirmYesNo(question, options = {}) {
+    const interactive = options.interactive ?? process.stdin.isTTY === true;
+    if (!interactive)
+        return true;
+    const ask = options.ask ?? defaultAsk;
+    const answer = (await ask(`${question} [Y/n] `)).trim().toLowerCase();
+    return answer !== "n" && answer !== "no";
+}

package/dist/types.d.ts

@@ -109,6 +109,23 @@ export interface PlanRun {
     status?: string | undefined;
     [key: string]: unknown;
 }
+export interface PlanRunSummary {
+    id: string;
+    status: string;
+    triggerSource: string | null;
+    executionMode: string;
+    totalCases: number;
+    completedCases: number;
+    passedCases: number;
+    failedCases: number;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+export interface PlanRunList {
+    items: PlanRunSummary[];
+    nextCursor?: string | undefined;
+}
 export interface Device {
     arn?: string | undefined;
     name?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autifyhq/aximo-cli",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Autify Aximo Command Line Interface (CLI)",
   "keywords": [
     "autify",