@autifyhq/aximo-cli 0.7.0 → 0.9.0

package/dist/mobile-control/tunnel.js

@@ -49,10 +49,43 @@ function defaultConnect(wsUrl, deviceToken) {
         timeout: 10000,
     });
 }
+// 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) {
+    // 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
+    // dropped even if a gateway instance lost its in-memory lock.
+    let activeSession = null;
+    socket.on("session_acquired", (args) => {
+        const sessionId = args?.sessionId;
+        if (typeof sessionId === "string" && sessionId) {
+            activeSession = { id: sessionId, lastSeenAt: Date.now() };
+        }
+    });
+    socket.on("session_released", (args) => {
+        // Only the owner's release clears the guard; a takeover by a new session is
+        // announced via session_acquired, so an unmatched release is ignored.
+        const sessionId = args?.sessionId;
+        if (activeSession && activeSession.id === sessionId) {
+            activeSession = null;
+        }
+    });
     const on = (event, handler) => {
         socket.on(event, (rawArgs, ack) => {
-            const args = (rawArgs ?? {});
+            // Destructure the routing-only tag off a clone so the caller's payload
+            // object is never mutated.
+            const { __sessionId: sessionId, ...args } = (rawArgs ?? {});
+            if (typeof sessionId === "string" && sessionId) {
+                if (activeSession &&
+                    activeSession.id !== sessionId &&
+                    Date.now() - activeSession.lastSeenAt < SESSION_LEASE_MS) {
+                    ack?.(fail(new Error("Device is busy with another session")));
+                    return;
+                }
+                activeSession = { id: sessionId, lastSeenAt: Date.now() };
+            }
             void handler(args)
                 .then((result) => ack?.(result))
                 .catch((err) => ack?.(fail(err)));
@@ -97,6 +130,29 @@ export function registerHandlers(socket, controller, installApp) {
         await controller.swipe(r.coords[0], r.coords[1], r.coords[2], r.coords[3], num(args["duration"], 300));
         return ok();
     });
+    on("pinch_zoom", async (args) => {
+        const r = requireCoords(args, ["x", "y"]);
+        if ("error" in r)
+            return { ok: false, error: `pinch_zoom ${r.error}` };
+        const scale = reqNum(args, "scale");
+        if (scale === null)
+            return { ok: false, error: "pinch_zoom requires a numeric scale" };
+        await controller.pinchZoom(r.coords[0], r.coords[1], scale, num(args["duration"], 600));
+        return ok();
+    });
+    on("rotate_device", async (args) => {
+        const orientation = String(args["orientation"] ?? "").toLowerCase();
+        if (orientation !== "portrait" && orientation !== "landscape") {
+            return { ok: false, error: 'rotate_device requires orientation "portrait" or "landscape"' };
+        }
+        return asActionResult(await controller.rotateDevice(orientation));
+    });
+    on("set_location", async (args) => {
+        const r = requireCoords(args, ["latitude", "longitude"]);
+        if ("error" in r)
+            return { ok: false, error: `set_location ${r.error}` };
+        return asActionResult(await controller.setLocation(r.coords[0], r.coords[1], num(args["altitude"], 0)));
+    });
     on("input", async (args) => asActionResult(await controller.typeText(String(args["text"] ?? ""))));
     on("key", async (args) => asActionResult(await controller.pressKey(String(args["key"] ?? ""))));
     on("launch_app", async (args) => asActionResult(await controller.launchApp(String(args["app"] ?? ""))));

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

@@ -20,12 +20,15 @@ function stubController(overrides = {}) {
         doubleTap: vi.fn(async () => { }),
         longPress: vi.fn(async () => { }),
         swipe: vi.fn(async () => { }),
+        pinchZoom: vi.fn(async () => { }),
         typeText: vi.fn(async () => ({ ok: true })),
         pressKey: vi.fn(async () => ({ ok: true })),
         launchApp: vi.fn(async () => ({ ok: true })),
         findElement: vi.fn(async () => ({ ok: true })),
         clearText: vi.fn(async () => ({ ok: true })),
         hideKeyboard: vi.fn(async () => ({ ok: true })),
+        rotateDevice: vi.fn(async () => ({ ok: true })),
+        setLocation: vi.fn(async () => ({ ok: true })),
         close: vi.fn(async () => { }),
     };
     return { ...base, ...overrides };
@@ -116,6 +119,78 @@ describe("registerHandlers", () => {
             error: "no focused field",
         });
     });
+    it("pinch_zoom forwards center, scale, and duration", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { x: 100, y: 200, scale: 2, duration: 800 })).resolves.toEqual({
+            ok: true,
+        });
+        expect(pinchZoom).toHaveBeenCalledWith(100, 200, 2, 800);
+    });
+    it("pinch_zoom defaults duration to 600ms", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await socket.emit("pinch_zoom", { x: 1, y: 2, scale: 0.5 });
+        expect(pinchZoom).toHaveBeenCalledWith(1, 2, 0.5, 600);
+    });
+    it("pinch_zoom rejects a missing scale without calling the controller", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { x: 1, y: 2 })).resolves.toEqual({
+            ok: false,
+            error: "pinch_zoom requires a numeric scale",
+        });
+        expect(pinchZoom).not.toHaveBeenCalled();
+    });
+    it("pinch_zoom rejects missing coordinates", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { scale: 2 })).resolves.toEqual({
+            ok: false,
+            error: "pinch_zoom requires numeric coordinates",
+        });
+        expect(pinchZoom).not.toHaveBeenCalled();
+    });
+    it("rotate_device forwards a valid orientation", async () => {
+        const rotateDevice = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ rotateDevice }));
+        await expect(socket.emit("rotate_device", { orientation: "landscape" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(rotateDevice).toHaveBeenCalledWith("landscape");
+    });
+    it("rotate_device rejects an invalid orientation without calling the controller", async () => {
+        const rotateDevice = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ rotateDevice }));
+        await expect(socket.emit("rotate_device", { orientation: "sideways" })).resolves.toEqual({
+            ok: false,
+            error: 'rotate_device requires orientation "portrait" or "landscape"',
+        });
+        expect(rotateDevice).not.toHaveBeenCalled();
+    });
+    it("set_location forwards coordinates with altitude defaulting to 0", async () => {
+        const setLocation = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: 35.68, longitude: 139.69 })).resolves.toEqual({
+            ok: true,
+        });
+        expect(setLocation).toHaveBeenCalledWith(35.68, 139.69, 0);
+    });
+    it("set_location rejects a non-numeric latitude without calling the controller", async () => {
+        const setLocation = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: "35", longitude: 139.69 })).resolves.toEqual({
+            ok: false,
+            error: "set_location requires numeric coordinates",
+        });
+        expect(setLocation).not.toHaveBeenCalled();
+    });
+    it("set_location acks the structured failure from the controller", async () => {
+        const setLocation = vi.fn(async () => ({ ok: false, error: "mock location not allowed" }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: 1, longitude: 2, altitude: 30 })).resolves.toEqual({ ok: false, error: "mock location not allowed" });
+        expect(setLocation).toHaveBeenCalledWith(1, 2, 30);
+    });
     it("hide_keyboard acks ok", async () => {
         const hideKeyboard = vi.fn(async () => ({ ok: true }));
         const socket = wire(stubController({ hideKeyboard }));
@@ -153,3 +228,85 @@ describe("registerHandlers", () => {
         });
     });
 });
+describe("registerHandlers session guard", () => {
+    const BUSY = { ok: false, error: "Device is busy with another session" };
+    function fire(socket, event, args) {
+        socket.handlers.get(event)?.(args);
+    }
+    it("strips __sessionId for the handler without mutating the incoming payload", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        const payload = { x: 5, y: 9, __sessionId: "s1" };
+        await expect(socket.emit("tap", payload)).resolves.toEqual({ ok: true });
+        expect(tap).toHaveBeenCalledWith(5, 9);
+        expect(payload.__sessionId).toBe("s1");
+    });
+    it("rejects a second session's command while the first is active", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("accepts a new session after session_released for the active one", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", { sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+    it("ignores session_released for a session that is not active", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", { sessionId: "other" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("ignores session_released without a sessionId (malformed release)", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_released", {});
+        fire(socket, "session_released", { sessionId: null });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual(BUSY);
+        expect(tap).toHaveBeenCalledTimes(1);
+    });
+    it("switches owner on session_acquired and rejects the superseded session", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        fire(socket, "session_acquired", { sessionId: "s2" });
+        await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s1" })).resolves.toEqual(BUSY);
+        await expect(socket.emit("tap", { x: 5, y: 6, __sessionId: "s2" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+    it("allows takeover once the active session is idle past the lease", async () => {
+        vi.useFakeTimers();
+        try {
+            const tap = vi.fn(async () => { });
+            const socket = wire(stubController({ tap }));
+            await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+            vi.advanceTimersByTime(26 * 60 * 1000);
+            await expect(socket.emit("tap", { x: 3, y: 4, __sessionId: "s2" })).resolves.toEqual({
+                ok: true,
+            });
+            expect(tap).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("leaves untagged commands ungated (pre-tagging gateways)", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await socket.emit("tap", { x: 1, y: 2, __sessionId: "s1" });
+        await expect(socket.emit("tap", { x: 3, y: 4 })).resolves.toEqual({ ok: true });
+        expect(tap).toHaveBeenCalledTimes(2);
+    });
+});

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

@@ -18,6 +18,12 @@ export declare class WebDriverSession {
     private requireId;
     screenshot(): Promise<Buffer>;
     windowRect(): Promise<WindowRect>;
+    setOrientation(orientation: "PORTRAIT" | "LANDSCAPE"): Promise<void>;
+    setGeoLocation(location: {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+    }): Promise<void>;
     performActions(actions: unknown[]): Promise<void>;
     releaseActions(): Promise<void>;
     getActiveElement(): Promise<string | null>;
@@ -25,7 +31,7 @@ export declare class WebDriverSession {
     elementClick(elementRef: string): Promise<void>;
     elementClear(elementRef: string): Promise<void>;
     elementSendKeys(elementRef: string, text: string): Promise<void>;
+    elementDisplayed(elementRef: string): Promise<boolean>;
     execute(script: string, args?: unknown[]): Promise<unknown>;
-    setValueOnActiveElement(text: string): Promise<void>;
 }
 export declare const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";

package/dist/mobile-control/webdriver.js

@@ -84,6 +84,14 @@ export class WebDriverSession {
             y: Number(value?.y ?? 0),
         };
     }
+    async setOrientation(orientation) {
+        await this.transport.request("POST", `/session/${this.requireId()}/orientation`, {
+            orientation,
+        });
+    }
+    async setGeoLocation(location) {
+        await this.transport.request("POST", `/session/${this.requireId()}/location`, { location });
+    }
     async performActions(actions) {
         await this.transport.request("POST", `/session/${this.requireId()}/actions`, { actions });
     }
@@ -110,18 +118,16 @@ export class WebDriverSession {
     async elementSendKeys(elementRef, text) {
         await this.transport.request("POST", `/session/${this.requireId()}/element/${elementRef}/value`, { text, value: [...text] });
     }
+    async elementDisplayed(elementRef) {
+        const value = await this.transport.request("GET", `/session/${this.requireId()}/element/${elementRef}/displayed`);
+        return value === true;
+    }
     async execute(script, args = []) {
         return this.transport.request("POST", `/session/${this.requireId()}/execute/sync`, {
             script,
             args,
         });
     }
-    async setValueOnActiveElement(text) {
-        const active = await this.getActiveElement();
-        if (!active)
-            throw new Error("No active element to receive text");
-        await this.elementSendKeys(active, text);
-    }
 }
 export const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
 function elementId(value) {

package/dist/mutate.d.ts

@@ -5,7 +5,7 @@ export interface DryRunResult {
     url: string;
     body?: unknown;
 }
-export declare function dryRunEnvelope(method: string, path: string, body?: unknown): SuccessEnvelope<DryRunResult>;
+export declare function dryRunEnvelope(method: string, pathOrUrl: string, body?: unknown): SuccessEnvelope<DryRunResult>;
 export declare function resolveJsonOverride(jsonFlag: unknown): {
     body: Record<string, unknown>;
 } | {

package/dist/mutate.js

@@ -1,8 +1,10 @@
 import { formatError, formatSuccess, validationError } from "./output.js";
 import { parseJsonBody, JsonBodyError, OPENAPI_URL } from "./validate.js";
 import { getBaseUrl } from "./client.js";
-export function dryRunEnvelope(method, path, body) {
-    const url = `${getBaseUrl()}${path.startsWith("/") ? path : `/${path}`}`;
+export function dryRunEnvelope(method, pathOrUrl, body) {
+    const url = /^https?:\/\//.test(pathOrUrl)
+        ? pathOrUrl
+        : `${getBaseUrl()}${pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`}`;
     const data = { dryRun: true, method, url };
     if (body !== undefined)
         data.body = body;

package/dist/types.d.ts

@@ -19,8 +19,12 @@ export interface ErrorEnvelope {
 export type Envelope<T> = SuccessEnvelope<T> | ErrorEnvelope;
 export type Platform = "ANDROID" | "IOS";
 export type FileType = "ANDROID_APP" | "IOS_APP";
+export type ExecutionMode = "parallel" | "sequential";
+export type CaseType = "web" | "mobile" | "desktop" | "multi_device";
+export type CaseFormat = "gherkin" | "markdown" | "plain_text";
 export interface HealthStatus {
     status: string;
+    auth?: string | undefined;
 }
 export interface CreateSessionInput {
     title: string;
@@ -75,11 +79,30 @@ export interface CaseRunStatus {
 export interface PlanRunInput {
     model?: string | undefined;
     mobileConfig?: Record<string, unknown> | undefined;
+    executionMode?: ExecutionMode | undefined;
 }
 export interface PlanRunResult {
     success: boolean;
     planRunId: string;
     totalCases: number;
+    executionMode?: ExecutionMode | undefined;
+}
+export interface UpdatePlanInput {
+    title?: string | undefined;
+    description?: string | undefined;
+    executionMode?: ExecutionMode | undefined;
+    stopOnFailure?: boolean | undefined;
+}
+export interface UpdatePlanResult {
+    success: boolean;
+    plan: {
+        id: string;
+        title: string;
+        description: string | null;
+        executionMode: ExecutionMode;
+        stopOnFailure: boolean;
+        updatedAt: string;
+    };
 }
 export interface PlanRun {
     id: string;
@@ -123,10 +146,10 @@ export interface Project {
 export interface CreateCaseInput {
     projectId: string;
     scenario: string;
-    type?: string | undefined;
+    type?: CaseType | undefined;
     title?: string | undefined;
     description?: string | undefined;
-    format?: string | undefined;
+    format?: CaseFormat | undefined;
     startUrl?: string | undefined;
     directoryId?: string | undefined;
 }
@@ -134,6 +157,28 @@ export interface CreateCaseResult {
     success: boolean;
     caseId: string;
 }
+export interface UpdateCaseInput {
+    title?: string | undefined;
+    description?: string | undefined;
+    scenario?: string | undefined;
+    type?: CaseType | undefined;
+    format?: CaseFormat | undefined;
+    startUrl?: string | undefined;
+}
+export interface UpdateCaseResult {
+    success: boolean;
+    case: {
+        id: string;
+        projectId: string;
+        type: string;
+        title: string;
+        description: string | null;
+        scenario: string;
+        format: string;
+        startUrl: string | null;
+        updatedAt: string;
+    };
+}
 export interface DeleteCaseResult {
     success: boolean;
 }
@@ -151,9 +196,9 @@ export interface PlanCaseResult {
 }
 export interface SaveSessionAsCaseInput {
     title?: string | undefined;
-    type?: string | undefined;
+    type?: Exclude<CaseType, "multi_device"> | undefined;
     scenario?: string | undefined;
-    format?: string | undefined;
+    format?: CaseFormat | undefined;
 }
 export interface SaveSessionAsCaseResult {
     success: boolean;

package/dist/validate.d.ts

@@ -1,10 +1,15 @@
-import type { Platform, FileType } from "./types.js";
+import type { CaseFormat, CaseType, ExecutionMode, FileType, Platform } from "./types.js";
 export declare function optionalString(name: string, value: unknown): string | undefined;
 export declare function parseStringList(name: string, value: unknown): string[] | undefined;
 export declare function requireString(name: string, value: unknown): string;
 export declare function requireId(name: string, value: unknown): string;
 export declare function parsePlatform(value: unknown): Platform | undefined;
 export declare function parseFileType(value: unknown): FileType | undefined;
+export declare function parseExecutionMode(value: unknown): ExecutionMode | undefined;
+export declare function parseCaseType(value: unknown): CaseType | undefined;
+export declare function parseSaveAsCaseType(value: unknown): Exclude<CaseType, "multi_device"> | undefined;
+export declare function parseCaseFormat(value: unknown): CaseFormat | undefined;
+export declare function parseOptionalBoolean(name: string, value: unknown): boolean | undefined;
 export declare function parseTags(value: unknown): string[] | undefined;
 export declare const OPENAPI_URL = "https://aximo.autify.com/openapi.yaml";
 export declare class JsonBodyError extends Error {

package/dist/validate.js

@@ -56,6 +56,52 @@ export function parseFileType(value) {
     }
     return value;
 }
+const EXECUTION_MODES = new Set(["parallel", "sequential"]);
+export function parseExecutionMode(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string" || !EXECUTION_MODES.has(value)) {
+        throw new Error(`executionMode must be parallel or sequential (got ${String(value)})`);
+    }
+    return value;
+}
+const CASE_TYPES = new Set(["web", "mobile", "desktop", "multi_device"]);
+export function parseCaseType(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string" || !CASE_TYPES.has(value)) {
+        throw new Error(`type must be web, mobile, desktop, or multi_device (got ${String(value)})`);
+    }
+    return value;
+}
+// save-as-case's server schema accepts a narrower set than case create/update.
+export function parseSaveAsCaseType(value) {
+    const parsed = parseCaseType(value);
+    if (parsed === "multi_device") {
+        throw new Error(`type must be web, mobile, or desktop (got ${String(value)})`);
+    }
+    return parsed;
+}
+const CASE_FORMATS = new Set(["gherkin", "markdown", "plain_text"]);
+export function parseCaseFormat(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string" || !CASE_FORMATS.has(value)) {
+        throw new Error(`format must be gherkin, markdown, or plain_text (got ${String(value)})`);
+    }
+    return value;
+}
+// Tri-state boolean for PATCH-style flags: absent means "leave unchanged",
+// so a citty boolean (which defaults to false) would silently overwrite.
+export function parseOptionalBoolean(name, value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (value === true || value === "true")
+        return true;
+    if (value === false || value === "false")
+        return false;
+    throw new Error(`${name} must be true or false (got ${String(value)})`);
+}
 export function parseTags(value) {
     return parseStringList("tags", value);
 }

package/dist/validate.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { requireString, requireId, parsePlatform, parseFileType, parseTags, parseJsonObject, parseJsonBody, JsonBodyError, } from "./validate.js";
+import { requireString, requireId, parseCaseFormat, parseCaseType, parsePlatform, parseSaveAsCaseType, parseFileType, parseTags, parseJsonObject, parseJsonBody, JsonBodyError, } from "./validate.js";
 describe("requireId", () => {
     it("accepts plain IDs", () => {
         expect(requireId("sessionId", "abc123_-")).toBe("abc123_-");
@@ -94,3 +94,41 @@ describe("parseJsonObject", () => {
         expect(parseJsonObject("x", "")).toBeUndefined();
     });
 });
+describe("parseCaseType", () => {
+    it("accepts all case types", () => {
+        expect(parseCaseType("web")).toBe("web");
+        expect(parseCaseType("mobile")).toBe("mobile");
+        expect(parseCaseType("desktop")).toBe("desktop");
+        expect(parseCaseType("multi_device")).toBe("multi_device");
+    });
+    it("returns undefined for absent values", () => {
+        expect(parseCaseType(undefined)).toBeUndefined();
+        expect(parseCaseType("")).toBeUndefined();
+    });
+    it("rejects unknown values", () => {
+        expect(() => parseCaseType("banana")).toThrow(/must be web, mobile, desktop/);
+    });
+});
+describe("parseSaveAsCaseType", () => {
+    it("accepts the narrower save-as-case set", () => {
+        expect(parseSaveAsCaseType("web")).toBe("web");
+        expect(parseSaveAsCaseType("desktop")).toBe("desktop");
+    });
+    it("rejects multi_device, which the save-as-case endpoint does not accept", () => {
+        expect(() => parseSaveAsCaseType("multi_device")).toThrow(/must be web, mobile, or desktop/);
+    });
+});
+describe("parseCaseFormat", () => {
+    it("accepts all formats", () => {
+        expect(parseCaseFormat("gherkin")).toBe("gherkin");
+        expect(parseCaseFormat("markdown")).toBe("markdown");
+        expect(parseCaseFormat("plain_text")).toBe("plain_text");
+    });
+    it("returns undefined for absent values", () => {
+        expect(parseCaseFormat(undefined)).toBeUndefined();
+        expect(parseCaseFormat("")).toBeUndefined();
+    });
+    it("rejects unknown values", () => {
+        expect(() => parseCaseFormat("klingon")).toThrow(/must be gherkin, markdown, or plain_text/);
+    });
+});

package/package.json

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