@autifyhq/aximo-cli 0.11.1 → 0.13.0

package/README.md

@@ -660,7 +660,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 21 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 7 that author content (create 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 24 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), 8 that author content (create, update, and delete cases, create and update 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/commands/mcp/server.test.js

@@ -24,7 +24,7 @@ async function connect() {
     };
 }
 describe("createMcpServer wiring", () => {
-    it("exposes all 21 tools through tools/list with valid JSON Schema", async () => {
+    it("exposes all 24 tools through tools/list with valid JSON Schema", async () => {
         const { client, cleanup } = await connect();
         try {
             const { tools } = await client.listTools();
@@ -40,13 +40,16 @@ describe("createMcpServer wiring", () => {
                 "aximo_list_projects",
                 "aximo_list_sessions",
                 "aximo_create_case",
+                "aximo_update_case",
                 "aximo_delete_case",
+                "aximo_run_case",
                 "aximo_create_plan",
                 "aximo_add_case_to_plan",
                 "aximo_remove_case_from_plan",
                 "aximo_list_plans",
                 "aximo_get_plan",
                 "aximo_update_plan",
+                "aximo_run_plan",
                 "aximo_list_plan_runs",
                 "aximo_get_plan_run",
                 "aximo_save_session_as_case",

package/dist/commands/mcp/tools.js

@@ -31,8 +31,12 @@ async function call(fn) {
         }
         if (status === 404)
             return err(e.message || "Not found");
-        if (status === 429)
-            return err("Rate limited", "Aximo enforces a daily session limit.");
+        if (status === 429) {
+            const retryAfter = e.retryAfter;
+            return err("Rate limited", retryAfter
+                ? `Back off and retry after ${retryAfter} seconds.`
+                : "Back off before retrying; Aximo rate-limits requests per organization.");
+        }
         if (typeof status === "number")
             return err(`HTTP ${status}: ${e.message}`);
         if (e.message.startsWith("No API key configured")) {
@@ -54,6 +58,18 @@ function buildQuery(params) {
     }
     return out;
 }
+// Mobile app selection accepted by the run triggers (multi-app, max 3).
+// ARN fields are the encrypted tokens Aximo returns, never raw AWS ARNs.
+const runAppsSchema = z
+    .array(z.object({
+    uploadArn: z
+        .string()
+        .describe("Encrypted upload token (from aximo_get_case config or `aximo upload`)."),
+    uploadType: z.enum(["own_app", "existing", "sample"]),
+    appName: z.string().nullable(),
+    bundleId: z.string().optional(),
+}))
+    .max(3);
 export function defineTools(deps = {}) {
     return [
         {
@@ -186,7 +202,7 @@ export function defineTools(deps = {}) {
         {
             name: "aximo_get_case",
             title: "Get test case",
-            description: "Get the full scenario text and metadata for a saved test case. Useful for grounding generated Playwright specs.",
+            description: "Get the full scenario text and metadata for a saved test case, including its per-target default configuration (mobile, web hostname overrides, desktop, multi-device) — the run trigger's per-run override fields supersede those defaults. Useful for grounding generated Playwright specs.",
             inputSchema: {
                 caseId: z.string().uuid(),
             },
@@ -201,17 +217,37 @@ export function defineTools(deps = {}) {
             inputSchema: {
                 projectId: z.string().uuid(),
                 scenario: z.string().min(1),
-                type: z.enum(["web", "mobile", "desktop"]).optional(),
+                type: z.enum(["web", "mobile", "desktop", "multi_device"]).optional(),
                 title: z.string().min(1).max(500).optional(),
                 description: z.string().optional(),
                 format: z.enum(["gherkin", "markdown", "plain_text"]).optional(),
-                startUrl: z.string().url().optional(),
+                startUrl: z.string().url().nullable().optional(),
                 directoryId: z.string().uuid().optional(),
             },
             handler: async (input) => call(async () => {
                 return await request("/api/cases", { method: "POST", body: input }, deps);
             }),
         },
+        {
+            name: "aximo_update_case",
+            title: "Update test case",
+            description: "Update a test case's title, description, scenario, type, format, or startUrl (pass null to clear startUrl). Omitted fields are left unchanged; at least one field is required. Per-target device configuration cannot be changed over the API, and changing type does not create or clear it (e.g. switching to mobile leaves apiMobileConfig null until set in the dashboard).",
+            inputSchema: {
+                caseId: z.string().uuid(),
+                title: z.string().min(1).max(500).optional(),
+                description: z.string().optional(),
+                scenario: z.string().min(1).optional(),
+                type: z.enum(["web", "mobile", "desktop", "multi_device"]).optional(),
+                format: z.enum(["gherkin", "markdown", "plain_text"]).optional(),
+                startUrl: z.string().url().nullable().optional(),
+            },
+            handler: async ({ caseId, ...body }) => call(async () => {
+                if (Object.keys(body).length === 0) {
+                    throw new Error("at least one field to update is required");
+                }
+                return await request(`/api/cases/${encodeURIComponent(caseId)}`, { method: "PATCH", body }, deps);
+            }),
+        },
         {
             name: "aximo_delete_case",
             title: "Delete test case",
@@ -223,6 +259,45 @@ export function defineTools(deps = {}) {
                 return await request(`/api/cases/${encodeURIComponent(caseId)}`, { method: "DELETE" }, deps);
             }),
         },
+        {
+            name: "aximo_run_case",
+            title: "Run test case",
+            description: "Start a run of a saved test case and return the new sessionId. The case must be apiEnabled (aximo_get_case shows this). All fields except caseId are per-run overrides of the case's stored per-target configuration: omit them to run with the saved defaults. Poll aximo_get_session with the returned sessionId to follow the run; wait at least 5 seconds between polls.",
+            inputSchema: {
+                caseId: z.string().uuid(),
+                model: z
+                    .string()
+                    .optional()
+                    .describe("Agent model override (e.g. 'sonnet', 'haiku', 'auto'). Server-validated."),
+                hostnameOverrideIds: z
+                    .array(z.string().uuid())
+                    .optional()
+                    .describe("Web cases: hostname override ids to apply for this run."),
+                userDeviceId: z
+                    .string()
+                    .uuid()
+                    .optional()
+                    .describe("A user-owned (BYOD) device id; overrides the device bound on the case."),
+                deviceArn: z
+                    .string()
+                    .optional()
+                    .describe("Mobile cases: encrypted device token; overrides the saved device."),
+                deviceName: z.string().optional(),
+                platform: z.enum(["ANDROID", "IOS"]).optional(),
+                uploadArn: z
+                    .string()
+                    .optional()
+                    .describe("Mobile cases: encrypted app upload token; overrides the saved app."),
+                uploadType: z.enum(["own_app", "existing", "sample"]).optional(),
+                appName: z.string().optional(),
+                apps: runAppsSchema
+                    .optional()
+                    .describe("Mobile multi-app runs: up to 3 apps to install; overrides the saved apps and takes precedence over the single-app uploadArn/uploadType/appName fields."),
+            },
+            handler: async ({ caseId, ...body }) => call(async () => {
+                return await request(`/api/triggers/cases/${encodeURIComponent(caseId)}/run`, { method: "POST", body }, deps);
+            }),
+        },
         {
             name: "aximo_create_plan",
             title: "Create test plan",
@@ -303,20 +378,90 @@ export function defineTools(deps = {}) {
                 return await request(`/api/plans/${encodeURIComponent(planId)}`, { method: "PATCH", body }, deps);
             }),
         },
+        {
+            name: "aximo_run_plan",
+            title: "Run test plan",
+            description: "Start a run of a test plan (all its cases) and return the new planRunId, totalCases, and the effective executionMode. The plan must be apiEnabled (aximo_get_plan shows this). All fields except planId are per-run overrides of the plan's stored settings: omit them to run with the saved defaults. Poll aximo_get_plan_run with the returned planRunId to follow the run; wait at least 5 seconds between polls.",
+            inputSchema: {
+                planId: z.string().uuid(),
+                model: z
+                    .string()
+                    .optional()
+                    .describe("Agent model override (e.g. 'sonnet', 'haiku', 'auto'). Server-validated."),
+                executionMode: z
+                    .enum(["parallel", "sequential"])
+                    .optional()
+                    .describe("Override the plan's stored Execution setting for this run only."),
+                mobileConfig: z
+                    .object({
+                    deviceArn: z.string().describe("Encrypted device token."),
+                    deviceName: z.string(),
+                    platform: z.enum(["ANDROID", "IOS"]).optional(),
+                    uploadArn: z.string().optional().describe("Encrypted app upload token."),
+                    uploadType: z.enum(["own_app", "existing", "sample"]).optional(),
+                    appName: z.string().optional(),
+                    apps: runAppsSchema
+                        .optional()
+                        .describe("Takes precedence over the single-app uploadArn/uploadType/appName fields."),
+                })
+                    .optional()
+                    .describe("Device + app for the plan's mobile cases; overrides the plan's stored config."),
+                desktopConfig: z
+                    .object({
+                    devices: z.array(z.object({ userDeviceId: z.string().uuid() })).min(1),
+                })
+                    .optional()
+                    .describe("User-owned (BYOD) desktop devices to run desktop cases on; overrides the plan's stored desktop config."),
+                variables: z
+                    .array(z.object({
+                    name: z
+                        .string()
+                        .describe("Uppercase letters, digits, underscores; must start with a letter."),
+                    value: z.string(),
+                }))
+                    .optional()
+                    .describe("Per-run variable values merged over the plan's stored variables by name; never persisted on the plan."),
+            },
+            handler: async ({ planId, ...body }) => call(async () => {
+                return await request(`/api/triggers/plans/${encodeURIComponent(planId)}/run`, { method: "POST", body }, deps);
+            }),
+        },
         {
             name: "aximo_list_plan_runs",
             title: "List plan runs",
-            description: "List a plan's runs, newest first, without per-case detail. Use aximo_get_plan_run for one run's per-case breakdown. Paginate by passing the previous page's nextCursor as cursor. A run's status reflects execution, not the test verdict: read passedCases/failedCases to judge outcomes.",
+            description: "List plan runs, newest first, without per-case detail. Pass planId for one plan's runs, or projectId for run history across every plan in a workspace (each item then carries its plan's id and title); exactly one of the two is required, and status filtering is available with projectId. Use aximo_get_plan_run for one run's per-case breakdown. Paginate by passing the previous page's nextCursor as cursor. A run's status reflects execution, not the test verdict: read passedCases/failedCases to judge outcomes.",
             inputSchema: {
-                planId: z.string().uuid(),
+                planId: z
+                    .string()
+                    .uuid()
+                    .optional()
+                    .describe("Exactly one of planId or projectId is required."),
+                projectId: z
+                    .string()
+                    .uuid()
+                    .optional()
+                    .describe("Exactly one of planId or projectId is required."),
+                status: z
+                    .enum(["created", "running", "completed", "failed", "cancelled"])
+                    .optional()
+                    .describe("Only with projectId: restrict to runs with this execution status."),
                 limit: z.number().int().positive().max(50).optional(),
                 cursor: z
                     .string()
                     .optional()
                     .describe("nextCursor from the previous page (ISO 8601 createdAt of its last run)."),
             },
-            handler: async ({ planId, ...rest }) => call(async () => {
-                return await request(`/api/triggers/plans/${encodeURIComponent(planId)}/runs`, { query: buildQuery(rest) }, deps);
+            handler: async ({ planId, projectId, status, ...rest }) => call(async () => {
+                if (!planId === !projectId) {
+                    throw new Error("pass exactly one of planId or projectId");
+                }
+                if (planId) {
+                    if (status) {
+                        throw new Error("the status filter requires projectId");
+                    }
+                    return await request(`/api/triggers/plans/${encodeURIComponent(planId)}/runs`, { query: buildQuery(rest) }, deps);
+                }
+                return await request("/api/plan-runs", { query: buildQuery({ projectId, status, ...rest }) }, deps);
             }),
         },
         {

package/dist/commands/mcp/tools.test.js

@@ -32,13 +32,16 @@ describe("defineTools", () => {
             "aximo_list_cases",
             "aximo_get_case",
             "aximo_create_case",
+            "aximo_update_case",
             "aximo_delete_case",
+            "aximo_run_case",
             "aximo_create_plan",
             "aximo_add_case_to_plan",
             "aximo_remove_case_from_plan",
             "aximo_list_plans",
             "aximo_get_plan",
             "aximo_update_plan",
+            "aximo_run_plan",
             "aximo_list_plan_runs",
             "aximo_get_plan_run",
             "aximo_save_session_as_case",
@@ -146,6 +149,131 @@ describe("aximo_list_projects", () => {
         expect(new URL(captured.url).pathname).toBe("/api/organizations/projects");
     });
 });
+describe("aximo_update_case", () => {
+    const caseId = "55555555-5555-4555-9555-555555555555";
+    it("PATCHes /api/cases/:id with only the provided fields", async () => {
+        let body = null;
+        const payload = {
+            success: true,
+            case: {
+                id: caseId,
+                projectId: "p1",
+                type: "web",
+                title: "Renamed",
+                description: null,
+                scenario: "Given a renamed page",
+                format: "gherkin",
+                startUrl: null,
+                updatedAt: "2026-08-14T00:00:00.000Z",
+            },
+        };
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/${caseId}`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json(payload);
+        }));
+        const tool = byName(defineTools(), "aximo_update_case");
+        const result = await tool.handler({
+            caseId,
+            title: "Renamed",
+            scenario: "Given a renamed page",
+        });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(body).toEqual({ title: "Renamed", scenario: "Given a renamed page" });
+    });
+    it("rejects an update with no fields instead of issuing an empty PATCH", async () => {
+        let called = false;
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/${caseId}`, () => {
+            called = true;
+            return HttpResponse.json({ success: true });
+        }));
+        const tool = byName(defineTools(), "aximo_update_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("at least one field to update is required");
+        expect(called).toBe(false);
+    });
+    it("passes startUrl: null through as an explicit clear, not an empty update", async () => {
+        let body = null;
+        server.use(http.patch(`${TEST_BASE_URL}/api/cases/${caseId}`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true });
+        }));
+        const tool = byName(defineTools(), "aximo_update_case");
+        const result = await tool.handler({ caseId, startUrl: null });
+        expect(result.isError).toBeUndefined();
+        expect(body).toEqual({ startUrl: null });
+    });
+});
+describe("aximo_run_case", () => {
+    const caseId = "77777777-7777-4777-9777-777777777777";
+    it("POSTs /api/triggers/cases/:id/run with the per-run overrides and returns sessionId", async () => {
+        let body = null;
+        let apiKey = null;
+        const payload = { success: true, sessionId: "88888888-8888-4888-9888-888888888888" };
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, async ({ request: req }) => {
+            apiKey = req.headers.get("x-api-key");
+            body = await req.json();
+            return HttpResponse.json(payload, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({
+            caseId,
+            model: "sonnet",
+            hostnameOverrideIds: ["99999999-9999-4999-9999-999999999999"],
+            apps: [{ uploadArn: "tok-1", uploadType: "own_app", appName: null }],
+        });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(apiKey).toBe("test-key");
+        expect(body).toEqual({
+            model: "sonnet",
+            hostnameOverrideIds: ["99999999-9999-4999-9999-999999999999"],
+            apps: [{ uploadArn: "tok-1", uploadType: "own_app", appName: null }],
+        });
+    });
+    it("sends an empty body when only caseId is given, so the saved config applies", async () => {
+        let body = null;
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true, sessionId: "s" }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBeUndefined();
+        expect(body).toEqual({});
+    });
+    it("surfaces the apiEnabled rejection as the error message", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, () => HttpResponse.json({ error: "API access is not enabled for this case" }, { status: 403 })));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("API access is not enabled for this case");
+    });
+    it("surfaces the insufficient-credits rejection distinctly", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, () => HttpResponse.json({ error: "Insufficient credits to start session" }, { status: 403 })));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("Insufficient credits to start session");
+    });
+    it("maps a 429 to a rate-limit error an agent can back off on", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, () => HttpResponse.json({ error: "Rate limit exceeded. Try again later." }, { status: 429, headers: { "Retry-After": "60" } })));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBe(true);
+        const payload = parsePayload(result);
+        expect(payload.error).toMatch(/Rate limited/);
+        expect(payload.hint).toBe("Back off and retry after 60 seconds.");
+    });
+    it("returns the API's 404 for a case outside the organization without leaking existence", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/${caseId}/run`, () => HttpResponse.json({ error: "Test case not found" }, { status: 404 })));
+        const tool = byName(defineTools(), "aximo_run_case");
+        const result = await tool.handler({ caseId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("Test case not found");
+    });
+});
 describe("aximo_list_plans", () => {
     const projectId = "44444444-4444-4444-8444-444444444444";
     it("calls /api/plans, passing filters through as query params", async () => {
@@ -247,6 +375,63 @@ describe("aximo_update_plan", () => {
         expect(called).toBe(false);
     });
 });
+describe("aximo_run_plan", () => {
+    const planId = "aaaaaaaa-aaaa-4aaa-9aaa-aaaaaaaaaaaa";
+    it("POSTs /api/triggers/plans/:id/run with the per-run overrides and returns planRunId", async () => {
+        let body = null;
+        const payload = {
+            success: true,
+            planRunId: "bbbbbbbb-bbbb-4bbb-9bbb-bbbbbbbbbbbb",
+            totalCases: 3,
+            executionMode: "sequential",
+        };
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/plans/${planId}/run`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json(payload, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_run_plan");
+        const result = await tool.handler({
+            planId,
+            executionMode: "sequential",
+            mobileConfig: { deviceArn: "tok-device", deviceName: "Pixel 8", platform: "ANDROID" },
+            desktopConfig: { devices: [{ userDeviceId: "cccccccc-cccc-4ccc-9ccc-cccccccccccc" }] },
+            variables: [{ name: "BASE_URL", value: "https://staging.example.com" }],
+        });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(body).toEqual({
+            executionMode: "sequential",
+            mobileConfig: { deviceArn: "tok-device", deviceName: "Pixel 8", platform: "ANDROID" },
+            desktopConfig: { devices: [{ userDeviceId: "cccccccc-cccc-4ccc-9ccc-cccccccccccc" }] },
+            variables: [{ name: "BASE_URL", value: "https://staging.example.com" }],
+        });
+    });
+    it("sends an empty body when only planId is given, so the plan's stored settings apply", async () => {
+        let body = null;
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/plans/${planId}/run`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true, planRunId: "r", totalCases: 1 }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_run_plan");
+        const result = await tool.handler({ planId });
+        expect(result.isError).toBeUndefined();
+        expect(body).toEqual({});
+    });
+    it("surfaces the apiEnabled rejection as the error message", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/plans/${planId}/run`, () => HttpResponse.json({ error: "API access is not enabled for this plan" }, { status: 403 })));
+        const tool = byName(defineTools(), "aximo_run_plan");
+        const result = await tool.handler({ planId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("API access is not enabled for this plan");
+    });
+    it("returns the API's 404 for a plan outside the organization without leaking existence", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/plans/${planId}/run`, () => HttpResponse.json({ error: "Test plan not found" }, { status: 404 })));
+        const tool = byName(defineTools(), "aximo_run_plan");
+        const result = await tool.handler({ planId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("Test plan not found");
+    });
+});
 describe("aximo_list_plan_runs", () => {
     const planId = "77777777-7777-4777-9777-777777777777";
     it("calls /api/triggers/plans/:id/runs, passing limit and cursor through", async () => {
@@ -255,7 +440,7 @@ describe("aximo_list_plan_runs", () => {
             items: [
                 {
                     id: "88888888-8888-4888-9888-888888888888",
-                    status: "succeeded",
+                    status: "completed",
                     triggerSource: "api",
                     executionMode: "parallel",
                     totalCases: 3,
@@ -292,6 +477,66 @@ describe("aximo_list_plan_runs", () => {
         expect(result.isError).toBe(true);
         expect(parsePayload(result).error).toBe("Test plan not found");
     });
+    it("calls /api/plan-runs when given a projectId, passing status through", async () => {
+        const projectId = "44444444-4444-4444-8444-444444444444";
+        let url = null;
+        const payload = {
+            items: [
+                {
+                    id: "88888888-8888-4888-9888-888888888888",
+                    planId,
+                    plan: { id: planId, title: "Nightly regression" },
+                    status: "failed",
+                    triggerSource: "api",
+                    executionMode: "parallel",
+                    totalCases: 3,
+                    completedCases: 3,
+                    passedCases: 2,
+                    failedCases: 1,
+                    startedAt: "2026-08-01T00:00:00.000Z",
+                    completedAt: "2026-08-01T00:10:00.000Z",
+                    createdAt: "2026-08-01T00:00:00.000Z",
+                },
+            ],
+            nextCursor: "2026-08-01T00:00:00.000Z",
+        };
+        server.use(http.get(`${TEST_BASE_URL}/api/plan-runs`, ({ request: req }) => {
+            url = new URL(req.url);
+            return HttpResponse.json(payload);
+        }));
+        const tool = byName(defineTools(), "aximo_list_plan_runs");
+        const result = await tool.handler({
+            projectId,
+            status: "failed",
+            limit: 5,
+            cursor: "2026-08-02T00:00:00.000Z",
+        });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(url).not.toBeNull();
+        expect(url.searchParams.get("projectId")).toBe(projectId);
+        expect(url.searchParams.get("status")).toBe("failed");
+        expect(url.searchParams.get("limit")).toBe("5");
+        expect(url.searchParams.get("cursor")).toBe("2026-08-02T00:00:00.000Z");
+    });
+    it("rejects calls with both, or neither, of planId and projectId", async () => {
+        const tool = byName(defineTools(), "aximo_list_plan_runs");
+        const both = await tool.handler({
+            planId,
+            projectId: "44444444-4444-4444-8444-444444444444",
+        });
+        expect(both.isError).toBe(true);
+        expect(parsePayload(both).error).toBe("pass exactly one of planId or projectId");
+        const neither = await tool.handler({});
+        expect(neither.isError).toBe(true);
+        expect(parsePayload(neither).error).toBe("pass exactly one of planId or projectId");
+    });
+    it("rejects the status filter without projectId", async () => {
+        const tool = byName(defineTools(), "aximo_list_plan_runs");
+        const result = await tool.handler({ planId, status: "failed" });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("the status filter requires projectId");
+    });
 });
 describe("aximo_get_plan_run", () => {
     const planId = "77777777-7777-4777-9777-777777777777";
@@ -299,7 +544,7 @@ describe("aximo_get_plan_run", () => {
     it("calls /api/triggers/plans/:id/runs/:runId and returns the run with cases", async () => {
         const payload = {
             id: planRunId,
-            status: "succeeded",
+            status: "completed",
             triggerSource: "api",
             executionMode: "sequential",
             totalCases: 1,
@@ -354,14 +599,23 @@ describe("call() error mapping", () => {
         const payload = parsePayload(result);
         expect(payload.error).toBe("Session was archived");
     });
-    it("flags 429 with the rate-limit hint", async () => {
+    it("flags 429 with a back-off hint when no Retry-After header is present", async () => {
         server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Too many requests" }, { status: 429 })));
         const tool = byName(defineTools(), "aximo_get_session_timeline");
         const result = await tool.handler({ sessionId });
         expect(result.isError).toBe(true);
         const payload = parsePayload(result);
         expect(payload.error).toBe("Rate limited");
-        expect(payload.hint).toMatch(/daily/i);
+        expect(payload.hint).toMatch(/back off/i);
+    });
+    it("carries the Retry-After value into the 429 hint so an agent knows how long to wait", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Too many requests" }, { status: 429, headers: { "Retry-After": "42" } })));
+        const tool = byName(defineTools(), "aximo_get_session_timeline");
+        const result = await tool.handler({ sessionId });
+        expect(result.isError).toBe(true);
+        const payload = parsePayload(result);
+        expect(payload.error).toBe("Rate limited");
+        expect(payload.hint).toBe("Back off and retry after 42 seconds.");
     });
     it("distinguishes a 500 with the HTTP-prefixed message", async () => {
         server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Internal server error" }, { status: 500 })));

package/dist/types.d.ts

@@ -161,7 +161,7 @@ export interface PlanDetail {
 export interface PlanRunSummary {
     id: string;
     status: string;
-    triggerSource: string | null;
+    triggerSource: string;
     executionMode: string;
     totalCases: number;
     completedCases: number;
@@ -171,8 +171,15 @@ export interface PlanRunSummary {
     completedAt: string | null;
     createdAt: string;
 }
-export interface PlanRunList {
-    items: PlanRunSummary[];
+export interface ProjectPlanRunSummary extends PlanRunSummary {
+    planId: string;
+    plan: {
+        id: string;
+        title: string;
+    };
+}
+export interface PlanRunList<T = PlanRunSummary> {
+    items: T[];
     nextCursor?: string | undefined;
 }
 export interface Device {
@@ -236,11 +243,11 @@ export interface UpdateCaseResult {
     case: {
         id: string;
         projectId: string;
-        type: string;
+        type: CaseType;
         title: string;
         description: string | null;
         scenario: string;
-        format: string;
+        format: CaseFormat;
         startUrl: string | null;
         updatedAt: string;
     };
@@ -366,6 +373,53 @@ export interface SessionCapture {
     createdAt: string;
     updatedAt: string;
 }
+export interface CaseAppInfo {
+    uploadArn: string;
+    uploadType: "own_app" | "existing" | "sample";
+    appName: string | null;
+    bundleId?: string;
+}
+export interface CaseMobileConfig {
+    deviceArn: string;
+    deviceName: string;
+    platform?: "ANDROID" | "IOS";
+    uploadArn?: string;
+    uploadType?: "own_app" | "existing" | "sample";
+    appName?: string;
+    bundleId?: string;
+    apps?: CaseAppInfo[];
+}
+export interface CaseWebConfig {
+    hostnameOverrideIds?: string[];
+}
+export interface CaseDesktopConfig {
+    userDeviceId: string;
+    name: string;
+    platform: "windows" | "macos" | "linux";
+    os: string | null;
+}
+export interface CaseMultiDeviceWebDevice {
+    kind: "web";
+    name: string;
+    startUrl?: string | null;
+    userDeviceId?: string;
+    localDeviceName?: string;
+}
+export interface CaseMultiDeviceMobileDevice {
+    kind: "mobile";
+    name: string;
+    mobilePlatform: "android" | "ios";
+    deviceArn?: string;
+    deviceName?: string;
+    userDeviceId?: string;
+    localDeviceName?: string;
+    uploadArn?: string;
+    uploadType?: "own_app" | "existing" | "sample";
+    appName?: string;
+    bundleId?: string;
+    apps?: CaseAppInfo[];
+}
+export type CaseMultiDeviceDevice = CaseMultiDeviceWebDevice | CaseMultiDeviceMobileDevice;
 export interface CaseDetail {
     id: string;
     projectId: string;
@@ -380,4 +434,8 @@ export interface CaseDetail {
     lastStatus: string | null;
     createdAt: string;
     updatedAt: string;
+    apiMobileConfig: CaseMobileConfig | null;
+    apiWebConfig: CaseWebConfig | null;
+    apiDesktopConfig: CaseDesktopConfig | null;
+    apiMultiDeviceConfig: CaseMultiDeviceDevice[] | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autifyhq/aximo-cli",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "Autify Aximo Command Line Interface (CLI)",
   "keywords": [
     "autify",
@@ -59,6 +59,7 @@
     "oxfmt": "0.45.0",
     "oxlint": "1.60.0",
     "postject": "1.0.0-alpha.6",
+    "resedit": "3.0.2",
     "secretlint": "11.7.1",
     "tsx": "4.21.0",
     "typescript": "6.0.2",