@autifyhq/aximo-cli 0.12.0 → 0.14.0

package/README.md

@@ -76,9 +76,14 @@ Run `aximo <command> --help` for detailed usage. `aximo schema [command.path]` r
 | `aximo session save-as-case` | Save a finished session as a reusable test case                |
 | `aximo case create`          | Create a test case                                             |
 | `aximo case update`          | Update a test case                                             |
-| `aximo case delete`          | Delete a test case                                             |
+| `aximo case archive`         | Archive a test case (hide it, keep its history)                |
+| `aximo case restore`         | Restore an archived test case                                  |
+| `aximo case delete`          | Permanently delete an archived test case (admin/owner)         |
 | `aximo plan create`          | Create a test plan                                             |
 | `aximo plan update`          | Update a test plan                                             |
+| `aximo plan archive`         | Archive a test plan (hide it; schedule is kept)                |
+| `aximo plan restore`         | Restore an archived test plan                                  |
+| `aximo plan delete`          | Permanently delete an archived test plan (admin/owner)         |
 | `aximo plan add-case`        | Add a case to a plan                                           |
 | `aximo plan remove-case`     | Remove a case from a plan                                      |
 | `aximo trigger case run`     | Trigger a dashboard-created test case                          |
@@ -154,7 +159,9 @@ aximo case create --project-id <id> --scenario <text> \
 
 aximo case update <caseId> [--title <t>] [--description <d>] [--scenario <text>] \
   [--type web|mobile|desktop|multi_device] [--format gherkin|markdown|plain_text] \
-  [--start-url <url>] [--json '<body>'] [--dry-run]
+  [--start-url <url>] [--mobile-config '<json>'] [--desktop-device <userDeviceId>] \
+  [--multi-device-config '<json>'] [--web-config '<json>'] [--json '<body>'] [--dry-run]
+aximo case archive <caseId> [--dry-run]
 aximo case delete <caseId> [--dry-run]
 
 aximo session save-as-case <sessionId> \
@@ -163,7 +170,9 @@ aximo session save-as-case <sessionId> \
   [--json '<body>'] [--dry-run]
 ```
 
-`case create` returns a `caseId` you can run with `aximo trigger case run`. `session save-as-case` persists a finished session (terminal status, not yet linked to a case) as a reusable case, carrying over its scenario and run config. Cases created either way have API access enabled by default, so they are triggerable immediately. `case delete` permanently removes a case: it is dropped from any plans it belongs to, and past run sessions are kept but detached.
+`case update` leaves omitted fields unchanged. Flags cannot express `null`, so clearing a description or start URL goes through the raw body: `--json '{"description": null}'`. In that raw body an empty string is stored as an empty description rather than a clear; the `--description` flag instead treats `""` as "leave unchanged".
+
+`case create` returns a `caseId` you can run with `aximo trigger case run`. `session save-as-case` persists a finished session (terminal status, not yet linked to a case) as a reusable case, carrying over its scenario and run config. Cases created either way have API access enabled by default, so they are triggerable immediately. `case archive` is the everyday removal verb: the case disappears from lists, plans, and new runs, while its run history is kept, and archiving an already-archived case succeeds. `case delete` is the permanent one, and it now requires the case to be archived first: deleting an unarchived case returns a `conflict` envelope telling you to archive it. Once deleted, the case is dropped from any plans it belongs to, its rows in past plan runs go with it, and the agent sessions themselves are kept but detached.
 
 ### Test plans
 
@@ -172,11 +181,12 @@ aximo plan create --project-id <id> --title <t> [--description <d>] [--json '<bo
 aximo plan update <planId> [--title <t>] [--description <d>] \
   [--execution-mode parallel|sequential] [--stop-on-failure true|false] \
   [--json '<body>'] [--dry-run]
+aximo plan archive     <planId> [--dry-run]
 aximo plan add-case    <planId> --case-id <caseId> [--json '<body>'] [--dry-run]
 aximo plan remove-case <planId> <caseId> [--dry-run]
 ```
 
-Build a runnable plan: `plan create` → `plan add-case` (repeat per case) → `aximo trigger plan run`. Plans created this way have API access enabled by default. Cases must belong to the same workspace as the plan. `plan update` changes only the flags you pass; `--execution-mode` sets the plan's stored Execution setting (sequential runs one case at a time in plan order) and `--stop-on-failure` marks the remaining cases as skipped after a failure, which only takes effect on sequential runs.
+Build a runnable plan: `plan create` → `plan add-case` (repeat per case) → `aximo trigger plan run`. Plans created this way have API access enabled by default. Cases must belong to the same workspace as the plan. `plan archive` hides a plan from lists, blocks new runs, and disables its schedule, keeping its cases and run history. `plan update` changes only the flags you pass; `--execution-mode` sets the plan's stored Execution setting (sequential runs one case at a time in plan order) and `--stop-on-failure` marks the remaining cases as skipped after a failure, which only takes effect on sequential runs.
 
 ### Triggers (test cases and plans)
 
@@ -660,7 +670,7 @@ claude mcp add aximo -- aximo mcp
 
 VS Code (Copilot agent mode) uses the same entry under a `servers` key in `.vscode/mcp.json`.
 
-The server exposes 22 tools: 14 read-only ones for inspecting sessions, cases, plans, and plan runs (`aximo_get_session_timeline` is the load-bearing one for Playwright export; `aximo_list_plans` and `aximo_get_plan` cover plan discovery; `aximo_list_plan_runs` and `aximo_get_plan_run` cover run-status polling) plus 8 that author content (create, update, and delete cases, create and update plans, save a session as a case). See the [MCP reference](./skills/aximo-cli/references/mcp.md) for per-client config paths, the full tool table, the Playwright export prompt, and a no-client smoke test.
+The server exposes 29 tools: 17 read-only ones for inspecting sessions, cases, plans, plan runs, devices, and uploads (`aximo_get_session_timeline` is the load-bearing one for Playwright export; `aximo_list_plans` and `aximo_get_plan` cover plan discovery; `aximo_list_plan_runs` and `aximo_get_plan_run` cover run-status polling; `aximo_list_devices`, `aximo_list_user_devices`, and `aximo_list_uploads` supply the device and upload tokens that case configs and run overrides take), 10 that author content (create, update, archive, and delete cases — including a case's per-target device configuration — create, update, and archive plans, save a session as a case), and 2 that trigger runs (`aximo_run_case` starts a case run and returns the `sessionId`; `aximo_run_plan` starts a plan run and returns the `planRunId` — both spend organization credits and require the case or plan to be `apiEnabled`). See the [MCP reference](./skills/aximo-cli/references/mcp.md) for per-client config paths, the full tool table, the Playwright export prompt, and a no-client smoke test.
 
 ## Agent Skills
 

package/dist/client.d.ts

@@ -1,6 +1,11 @@
 export declare const DEFAULT_BASE_URL = "https://aximo.autify.com";
 export declare function getApiKey(): string;
 export declare function getBaseUrl(): string;
+export interface HttpError extends Error {
+    status: number;
+    retryAfter?: string;
+    details?: unknown;
+}
 export interface RequestOptions {
     method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
     query?: Record<string, string | number | boolean | undefined>;

package/dist/client.js

@@ -15,27 +15,32 @@ export function getBaseUrl() {
     const raw = process.env["AXIMO_BASE_URL"] ?? config.baseUrl ?? DEFAULT_BASE_URL;
     return raw.replace(/\/+$/, "");
 }
-function httpError(status, message, retryAfter) {
-    const err = Object.assign(new Error(message), { status });
-    if (retryAfter !== undefined)
-        err.retryAfter = retryAfter;
-    return err;
-}
-async function errorMessage(res) {
+async function parseErrorBody(res) {
     const text = await res.text().catch(() => "");
     if (!text)
-        return res.statusText || `HTTP ${res.status}`;
+        return { message: res.statusText || `HTTP ${res.status}` };
     try {
         const parsed = JSON.parse(text);
-        if (typeof parsed.error === "string")
-            return parsed.error;
-        if (typeof parsed.message === "string")
-            return parsed.message;
+        const message = typeof parsed.error === "string"
+            ? parsed.error
+            : typeof parsed.message === "string"
+                ? parsed.message
+                : text;
+        return parsed.details === undefined ? { message } : { message, details: parsed.details };
     }
     catch {
-        // fall through
+        return { message: text };
     }
-    return text;
+}
+async function responseError(res) {
+    const { message, details } = await parseErrorBody(res);
+    const err = Object.assign(new Error(message), { status: res.status });
+    const retryAfter = res.headers.get("retry-after");
+    if (retryAfter !== null)
+        err.retryAfter = retryAfter;
+    if (details !== undefined)
+        err.details = details;
+    return err;
 }
 function buildUrl(baseUrl, path, query) {
     const url = new URL(path.startsWith("/") ? path : `/${path}`, `${baseUrl}/`);
@@ -67,8 +72,7 @@ export async function request(path, options = {}, deps = {}) {
     }
     const res = await fetchImpl(url, { method, headers, ...(body !== undefined ? { body } : {}) });
     if (!res.ok) {
-        const retryAfter = res.headers.get("retry-after") ?? undefined;
-        throw httpError(res.status, await errorMessage(res), retryAfter);
+        throw await responseError(res);
     }
     if (options.expectJson === false) {
         return undefined;
@@ -91,8 +95,7 @@ export async function putToPresignedUrl(url, rawBody, contentType, deps = {}) {
         body: rawBody,
     });
     if (!res.ok) {
-        const retryAfter = res.headers.get("retry-after") ?? undefined;
-        throw httpError(res.status, await errorMessage(res), retryAfter);
+        throw await responseError(res);
     }
 }
 export async function requestBuffer(path, deps = {}) {
@@ -102,8 +105,7 @@ export async function requestBuffer(path, deps = {}) {
     const url = buildUrl(baseUrl, path);
     const res = await fetchImpl(url, { method: "GET", headers: { "x-api-key": apiKey } });
     if (!res.ok) {
-        const retryAfter = res.headers.get("retry-after") ?? undefined;
-        throw httpError(res.status, await errorMessage(res), retryAfter);
+        throw await responseError(res);
     }
     return Buffer.from(await res.arrayBuffer());
 }
@@ -130,8 +132,7 @@ export async function requestToFile(path, destPath, deps = {}) {
         res = await fetchImpl(new URL(location, url).toString(), { method: "GET" });
     }
     if (!res.ok) {
-        const retryAfter = res.headers.get("retry-after") ?? undefined;
-        throw httpError(res.status, await errorMessage(res), retryAfter);
+        throw await responseError(res);
     }
     if (!res.body)
         throw new Error(`Empty response body from ${path}`);

package/dist/client.test.js

@@ -161,3 +161,31 @@ describe("request", () => {
         expect(seenMethod).toBe("PUT");
     });
 });
+describe("request error details", () => {
+    it("attaches the parsed details object to the thrown error", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => HttpResponse.json({ error: "Invalid request body", details: { path: "apiMobileConfig.deviceArn" } }, { status: 400 })));
+        await expect(request("/api/boom")).rejects.toMatchObject({
+            status: 400,
+            message: "Invalid request body",
+            details: { path: "apiMobileConfig.deviceArn" },
+        });
+    });
+    it("leaves details unset when the body is not JSON", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => HttpResponse.text("plain failure", { status: 502 })));
+        const err = (await request("/api/boom").catch((e) => e));
+        expect(err).toMatchObject({ status: 502, message: "plain failure" });
+        expect(err.details).toBeUndefined();
+    });
+    it("falls back to the raw text when a JSON body has no string error or message", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => HttpResponse.json({ code: 12 }, { status: 400 })));
+        await expect(request("/api/boom")).rejects.toMatchObject({
+            status: 400,
+            message: '{"code":12}',
+        });
+    });
+    it("falls back to the status when the body is empty", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => new HttpResponse(null, { status: 503 })));
+        const err = (await request("/api/boom").catch((e) => e));
+        expect(err.message).toMatch(/Service Unavailable|HTTP 503/);
+    });
+});

package/dist/commands/case/archive.d.ts

@@ -0,0 +1,20 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { ArchiveCaseResult, Envelope } from "../../types.js";
+export interface ArchiveCaseOptions {
+    caseId?: unknown;
+    dryRun?: unknown;
+}
+export declare function runCaseArchive(options: ArchiveCaseOptions, deps?: ClientDeps): Promise<Envelope<ArchiveCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly caseId: {
+        readonly type: "positional";
+        readonly description: "Case ID";
+        readonly required: true;
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/case/archive.js

@@ -0,0 +1,42 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { dryRunEnvelope } from "../../mutate.js";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { requireId } from "../../validate.js";
+export async function runCaseArchive(options, deps) {
+    let caseId;
+    try {
+        caseId = requireId("caseId", options.caseId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    const path = `/api/cases/${encodeURIComponent(caseId)}/archive`;
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", path);
+    }
+    try {
+        const res = await request(path, { method: "POST" }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "archive",
+        description: "Archive a test case (hides it from lists and plans; run history is kept)",
+    },
+    args: {
+        caseId: { type: "positional", description: "Case ID", required: true },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runCaseArchive({
+            caseId: args.caseId,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

package/dist/commands/case/case.test.js

@@ -3,6 +3,8 @@ import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
 import { runCaseCreate } from "./create.js";
 import { runCaseUpdate } from "./update.js";
 import { runCaseDelete } from "./delete.js";
+import { runCaseArchive } from "./archive.js";
+import { runCaseRestore } from "./restore.js";
 beforeAll(() => {
     process.env["AXIMO_API_KEY"] = "test-key";
     process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
@@ -110,6 +112,19 @@ describe("runCaseDelete", () => {
         if (!result.ok)
             expect(result.error.code).toBe("not_found");
     });
+    it("maps the archived-first 409 to conflict with an actionable hint", async () => {
+        server.use(http.delete(`${TEST_BASE_URL}/api/cases/c1`, () => HttpResponse.json({
+            error: "Test case must be archived before it can be permanently deleted. Archive it first with POST /api/cases/{caseId}/archive, then retry the delete.",
+        }, { status: 409 })));
+        const result = await runCaseDelete({ caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("conflict");
+            expect(result.error.retryable).toBe(false);
+            expect(result.error.message).toContain("must be archived");
+            expect(result.error.hint).toContain("aximo case archive");
+        }
+    });
     it("--dry-run returns a DELETE request without calling API", async () => {
         const result = await runCaseDelete({ caseId: "c1", dryRun: true });
         expect(result.ok).toBe(true);
@@ -119,6 +134,41 @@ describe("runCaseDelete", () => {
         }
     });
 });
+describe("runCaseArchive", () => {
+    it("POSTs the archive path and returns success", async () => {
+        let called = false;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases/c1/archive`, () => {
+            called = true;
+            return HttpResponse.json({ archived: true });
+        }));
+        const result = await runCaseArchive({ caseId: "c1" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.archived).toBe(true);
+        expect(called).toBe(true);
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runCaseArchive({});
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("maps 404 to not_found", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/cases/c1/archive`, () => HttpResponse.json({ error: "Test case not found" }, { status: 404 })));
+        const result = await runCaseArchive({ caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+    it("--dry-run returns a POST request without calling API", async () => {
+        const result = await runCaseArchive({ caseId: "c1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases/c1/archive`);
+        }
+    });
+});
 describe("runCaseUpdate", () => {
     it("PATCHes the provided fields and returns the updated case", async () => {
         let seen;
@@ -154,6 +204,9 @@ describe("runCaseUpdate", () => {
             scenario: "Given a user",
             format: "plain_text",
         });
+        // GEN-2844: flags cannot express null, so an unsupplied description must
+        // be dropped from the payload rather than sent as a clear.
+        expect(seen).not.toHaveProperty("description");
     });
     it("rejects when no fields are provided", async () => {
         const result = await runCaseUpdate({ caseId: "c1" });
@@ -171,6 +224,17 @@ describe("runCaseUpdate", () => {
         if (!badFormat.ok)
             expect(badFormat.error.code).toBe("validation_error");
     });
+    it("--json forwards description: null verbatim so it can be cleared (GEN-2844)", async () => {
+        let seen;
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/c1`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true });
+        }));
+        const raw = JSON.stringify({ description: null });
+        const result = await runCaseUpdate({ caseId: "c1", json: raw });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ description: null });
+    });
     it("--dry-run returns the PATCH request without calling the API", async () => {
         const result = await runCaseUpdate({ caseId: "c1", title: "t", dryRun: true });
         expect(result.ok).toBe(true);
@@ -180,3 +244,120 @@ describe("runCaseUpdate", () => {
         }
     });
 });
+describe("runCaseUpdate per-target config flags", () => {
+    const userDeviceId = "77777777-7777-4777-9777-777777777777";
+    it("maps the config flags onto the api*Config body keys", async () => {
+        let seen;
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/c1`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true });
+        }));
+        const result = await runCaseUpdate({
+            caseId: "c1",
+            type: "mobile",
+            mobileConfig: '{"deviceArn":"enc-d","deviceName":"Pixel 8","platform":"ANDROID"}',
+            desktopDevice: userDeviceId,
+            multiDeviceConfig: '[{"kind":"web","name":"A"},{"kind":"mobile","name":"B","mobilePlatform":"ios"}]',
+            webConfig: '{"hostnameOverrideIds":["h1"]}',
+        });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({
+            type: "mobile",
+            apiMobileConfig: { deviceArn: "enc-d", deviceName: "Pixel 8", platform: "ANDROID" },
+            apiDesktopConfig: { userDeviceId },
+            apiMultiDeviceConfig: [
+                { kind: "web", name: "A" },
+                { kind: "mobile", name: "B", mobilePlatform: "ios" },
+            ],
+            apiWebConfig: { hostnameOverrideIds: ["h1"] },
+        });
+    });
+    it("--dry-run shows the PATCH body with a config flag alone", async () => {
+        const result = await runCaseUpdate({ caseId: "c1", desktopDevice: userDeviceId, dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("PATCH");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases/c1`);
+            expect(result.data.body).toEqual({ apiDesktopConfig: { userDeviceId } });
+        }
+    });
+    it("rejects malformed or wrongly-shaped config JSON client-side", async () => {
+        const badJson = await runCaseUpdate({ caseId: "c1", mobileConfig: "{nope" });
+        expect(badJson.ok).toBe(false);
+        if (!badJson.ok) {
+            expect(badJson.error.code).toBe("validation_error");
+            expect(badJson.error.message).toContain("mobileConfig is not valid JSON");
+        }
+        const notArray = await runCaseUpdate({ caseId: "c1", multiDeviceConfig: '{"kind":"web"}' });
+        expect(notArray.ok).toBe(false);
+        if (!notArray.ok)
+            expect(notArray.error.message).toBe("multiDeviceConfig must be a JSON array");
+        const notObject = await runCaseUpdate({ caseId: "c1", webConfig: "[]" });
+        expect(notObject.ok).toBe(false);
+        if (!notObject.ok)
+            expect(notObject.error.message).toBe("webConfig must be a JSON object");
+    });
+    it("clears a config through --json", async () => {
+        let seen;
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/c1`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true });
+        }));
+        const result = await runCaseUpdate({ caseId: "c1", json: '{"apiMobileConfig":null}' });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ apiMobileConfig: null });
+    });
+    it("surfaces the feature gate from the API's error details", async () => {
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/c1`, () => HttpResponse.json({
+            error: "Desktop cases are not enabled for this organization",
+            details: { feature: "byodEnabled" },
+        }, { status: 403 })));
+        const result = await runCaseUpdate({ caseId: "c1", desktopDevice: userDeviceId });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.message).toContain("requires feature byodEnabled");
+            expect(result.error.hint).toMatch(/organization admin/);
+        }
+    });
+});
+describe("runCaseRestore", () => {
+    it("POSTs the restore path and returns success", async () => {
+        let called = false;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases/c1/restore`, () => {
+            called = true;
+            return HttpResponse.json({ restored: true });
+        }));
+        const result = await runCaseRestore({ caseId: "c1" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.restored).toBe(true);
+        expect(called).toBe(true);
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runCaseRestore({});
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("maps 404 to not_found", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/cases/c1/restore`, () => HttpResponse.json({ error: "Test case not found" }, { status: 404 })));
+        const result = await runCaseRestore({ caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+    it("--dry-run returns a POST request without calling API", async () => {
+        let called = false;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases/c1/restore`, () => {
+            called = true;
+            return HttpResponse.json({ restored: true });
+        }));
+        const result = await runCaseRestore({ caseId: "c1", dryRun: true });
+        expect(called).toBe(false);
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases/c1/restore`);
+        }
+    });
+});

package/dist/commands/case/delete.js

@@ -25,7 +25,10 @@ export async function runCaseDelete(options, deps) {
     }
 }
 export default defineCommand({
-    meta: { name: "delete", description: "Delete a test case" },
+    meta: {
+        name: "delete",
+        description: "Permanently delete an archived test case (archive it first with `aximo case archive`). Requires an org admin or owner",
+    },
     args: {
         caseId: { type: "positional", description: "Case ID", required: true },
         "dry-run": { type: "boolean", description: "Validate and show request without calling API" },

package/dist/commands/case/index.js

@@ -4,6 +4,8 @@ export default defineCommand({
     subCommands: {
         create: () => import("./create.js").then((m) => m.default),
         update: () => import("./update.js").then((m) => m.default),
+        archive: () => import("./archive.js").then((m) => m.default),
+        restore: () => import("./restore.js").then((m) => m.default),
         delete: () => import("./delete.js").then((m) => m.default),
     },
 });

package/dist/commands/case/restore.d.ts

@@ -0,0 +1,20 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { RestoreCaseResult, Envelope } from "../../types.js";
+export interface RestoreCaseOptions {
+    caseId?: unknown;
+    dryRun?: unknown;
+}
+export declare function runCaseRestore(options: RestoreCaseOptions, deps?: ClientDeps): Promise<Envelope<RestoreCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly caseId: {
+        readonly type: "positional";
+        readonly description: "Case ID";
+        readonly required: true;
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/case/restore.js

@@ -0,0 +1,42 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { dryRunEnvelope } from "../../mutate.js";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { requireId } from "../../validate.js";
+export async function runCaseRestore(options, deps) {
+    let caseId;
+    try {
+        caseId = requireId("caseId", options.caseId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    const path = `/api/cases/${encodeURIComponent(caseId)}/restore`;
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", path);
+    }
+    try {
+        const res = await request(path, { method: "POST" }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: {
+        name: "restore",
+        description: "Restore an archived test case (returns it to lists and plans)",
+    },
+    args: {
+        caseId: { type: "positional", description: "Case ID", required: true },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runCaseRestore({
+            caseId: args.caseId,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

package/dist/commands/case/update.d.ts

@@ -9,6 +9,10 @@ export interface UpdateCaseOptions {
     type?: unknown;
     format?: unknown;
     startUrl?: unknown;
+    mobileConfig?: unknown;
+    desktopDevice?: unknown;
+    multiDeviceConfig?: unknown;
+    webConfig?: unknown;
     json?: unknown;
     dryRun?: unknown;
 }
@@ -23,6 +27,7 @@ declare const _default: import("citty").CommandDef<{
     };
     readonly description: {
         readonly type: "string";
+        readonly description: "Cannot clear; use --json '{\"description\": null}' for that";
     };
     readonly scenario: {
         readonly type: "string";
@@ -37,6 +42,23 @@ declare const _default: import("citty").CommandDef<{
     };
     readonly "start-url": {
         readonly type: "string";
+        readonly description: "Cannot clear; use --json '{\"startUrl\": null}' for that";
+    };
+    readonly "mobile-config": {
+        readonly type: "string";
+        readonly description: "JSON object for apiMobileConfig ({deviceArn, deviceName, platform?, uploadArn?, uploadType?, appName?, bundleId?, apps?}); replaces the whole config. Clear with --json '{\"apiMobileConfig\":null}'";
+    };
+    readonly "desktop-device": {
+        readonly type: "string";
+        readonly description: "Registered BYOD desktop device id (aximo device status) for apiDesktopConfig. Clear with --json '{\"apiDesktopConfig\":null}'";
+    };
+    readonly "multi-device-config": {
+        readonly type: "string";
+        readonly description: "JSON array of 2-3 device entries ({kind: web|mobile, name, ...}) for apiMultiDeviceConfig; replaces the whole config. Clear with --json '{\"apiMultiDeviceConfig\":null}'";
+    };
+    readonly "web-config": {
+        readonly type: "string";
+        readonly description: "JSON object for apiWebConfig ({hostnameOverrideIds: [...]}); replaces the whole config. Clear with --json '{\"apiWebConfig\":null}'";
     };
     readonly json: {
         readonly type: "string";