@autifyhq/aximo-cli 0.2.0 → 0.3.0

package/README.md

@@ -36,11 +36,7 @@ Get your API key from **Settings → API Keys** in the [Aximo dashboard](https:/
 
 ## Configuration
 
-The CLI resolves each credential independently in this order:
-
-1. Value in `$AXIMO_HOME/config.json` (written by `aximo configure`)
-2. Environment variable
-3. Default (for base URL only: `https://aximo.autify.com`)
+Each credential resolves independently: the value in `$AXIMO_HOME/config.json` (written by `aximo configure`) wins, then the environment variable, then the default.
 
 | Variable         | Required | Default                    | Notes                                                        |
 | ---------------- | -------- | -------------------------- | ------------------------------------------------------------ |
@@ -48,60 +44,59 @@ The CLI resolves each credential independently in this order:
 | `AXIMO_BASE_URL` | No       | `https://aximo.autify.com` | Override for sandbox / self-hosted                           |
 | `AXIMO_HOME`     | No       | `~/.aximo`                 | Data directory (config, device credentials, embedded Python) |
 
-### Using `aximo configure`
+Set them interactively or pass flags — config is written to `$AXIMO_HOME/config.json` (mode `0600` where the OS supports it; Windows falls back to file ACLs), and an empty prompt keeps the existing value:
 
 ```bash
 aximo configure                              # interactive prompts
 aximo configure --base-url URL --api-key KEY # non-interactive
 ```
 
-The interactive flow prompts first for the base URL (empty → keep existing, else falls back to the Aximo default), then for the API key (empty → keep existing; errors if nothing is saved). Config is written to `$AXIMO_HOME/config.json` with mode `0600`. To change sandbox/prod, re-run `aximo configure` and enter a new URL.
-
-### Using environment variables
-
-If you'd rather keep credentials out of a file (CI, ephemeral shells), set env vars:
+Or keep credentials out of a file (CI, ephemeral shells) with env vars:
 
 ```bash
-# macOS / Linux
 export AXIMO_API_KEY=your-api-key
 export AXIMO_BASE_URL=https://aximo-sbx.autify.dev   # optional, prod is the default
-
-# Windows (PowerShell, persistent)
-[Environment]::SetEnvironmentVariable("AXIMO_API_KEY", "your-api-key", "User")
-[Environment]::SetEnvironmentVariable("AXIMO_BASE_URL", "https://aximo-sbx.autify.dev", "User")
 ```
 
+Credentials and device registrations are **per-environment** — to switch between production and sandbox (`https://aximo-sbx.autify.dev`), re-run `aximo configure` with the other `--base-url`.
+
 ## Commands
 
 Run `aximo <command> --help` for detailed usage. `aximo schema [command.path]` returns machine-readable argument introspection (e.g. `aximo schema session.create`).
 
-| Command                   | Description                                          |
-| ------------------------- | ---------------------------------------------------- |
-| `aximo configure`         | Save credentials to `$AXIMO_HOME/config.json`        |
-| `aximo health check`      | Check API reachability                               |
-| `aximo project list`      | List organization projects                           |
-| `aximo session create`    | Create and queue a test session                      |
-| `aximo session get`       | Get session status                                   |
-| `aximo trigger case run`  | Trigger a dashboard-created test case                |
-| `aximo trigger case get`  | Get triggered case status                            |
-| `aximo trigger plan run`  | Trigger a test plan                                  |
-| `aximo trigger plan get`  | Get plan run status                                  |
-| `aximo upload create`     | Create an upload slot for an APK/IPA                 |
-| `aximo upload list`       | List previously uploaded apps                        |
-| `aximo upload get`        | Poll upload processing status                        |
-| `aximo upload put`        | Upload binary file to the slot                       |
-| `aximo upload submit`     | Finalize upload and trigger processing               |
-| `aximo device list`       | List mobile devices from Device Farm                 |
-| `aximo device setup`      | First-time BYOD onboarding (API + Python + register) |
-| `aximo device register`   | Register this machine as a BYOD device               |
-| `aximo device connect`    | Start the BYOD agent and connect to the relay        |
-| `aximo device status`     | List your organization's BYOD devices                |
-| `aximo device ping`       | Check your BYOD device's server-side status          |
-| `aximo device doctor`     | Diagnose BYOD setup (env, Python, relay, status)     |
-| `aximo device logs`       | Show the BYOD agent log                              |
-| `aximo device unregister` | Remove a BYOD device server-side + clear local creds |
-| `aximo device reset`      | Remove BYOD local state (Python, deps, credentials)  |
-| `aximo schema`            | Show CLI surface as JSON                             |
+| Command                      | Description                                          |
+| ---------------------------- | ---------------------------------------------------- |
+| `aximo configure`            | Save credentials to `$AXIMO_HOME/config.json`        |
+| `aximo health check`         | Check API reachability                               |
+| `aximo project list`         | List organization projects                           |
+| `aximo session create`       | Create and queue a test session                      |
+| `aximo session get`          | Get session status                                   |
+| `aximo session save-as-case` | Save a finished session as a reusable test case      |
+| `aximo case create`          | Create a test case                                   |
+| `aximo plan create`          | Create a test plan                                   |
+| `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                |
+| `aximo trigger case get`     | Get triggered case status                            |
+| `aximo trigger plan run`     | Trigger a test plan                                  |
+| `aximo trigger plan get`     | Get plan run status                                  |
+| `aximo upload create`        | Create an upload slot for an APK/IPA                 |
+| `aximo upload list`          | List previously uploaded apps                        |
+| `aximo upload get`           | Poll upload processing status                        |
+| `aximo upload put`           | Upload binary file to the slot                       |
+| `aximo upload submit`        | Finalize upload and trigger processing               |
+| `aximo device list`          | List mobile devices from Device Farm                 |
+| `aximo device setup`         | First-time BYOD onboarding (API + Python + register) |
+| `aximo device register`      | Register this machine as a BYOD device               |
+| `aximo device connect`       | Start the BYOD agent and connect to the relay        |
+| `aximo device status`        | List your organization's BYOD devices                |
+| `aximo device ping`          | Check your BYOD device's server-side status          |
+| `aximo device doctor`        | Diagnose BYOD setup (env, Python, relay, status)     |
+| `aximo device logs`          | Show the BYOD agent log                              |
+| `aximo device unregister`    | Remove a BYOD device server-side + clear local creds |
+| `aximo device reset`         | Remove BYOD local state (Python, deps, credentials)  |
+| `aximo schema`               | Show CLI surface as JSON                             |
+| `aximo mcp`                  | Run a stdio MCP server for agents (see below)        |
 
 Mutating commands support `--json '<raw body>'` for direct OpenAPI payloads and `--dry-run` to preview requests without executing.
 
@@ -137,6 +132,32 @@ aximo session get <sessionId>
 
 Desktop sessions default to `platform=desktop`, `model=sonnet`. Mobile sessions require both `--device-arn` and `--upload-arn`.
 
+### Test cases
+
+```bash
+aximo case create --project-id <id> --scenario <text> \
+  [--type web|mobile|desktop] [--title <t>] [--description <d>] \
+  [--format gherkin|markdown|plain_text] [--start-url <url>] \
+  [--directory-id <id>] [--json '<body>'] [--dry-run]
+
+aximo session save-as-case <sessionId> \
+  [--title <t>] [--type web|mobile|desktop] \
+  [--scenario <text>] [--format gherkin|markdown|plain_text] \
+  [--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.
+
+### Test plans
+
+```bash
+aximo plan create --project-id <id> --title <t> [--description <d>] [--json '<body>'] [--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.
+
 ### Triggers (test cases and plans)
 
 ```bash
@@ -146,7 +167,7 @@ aximo trigger plan run  <planId> [...]
 aximo trigger plan get  <planId> <planRunId>
 ```
 
-Triggers dashboard-created test cases or plans. API access must be enabled in the Aximo dashboard settings. `trigger case run` returns a `sessionId` you can poll; `trigger plan run` returns per-case breakdown.
+Triggers a test case or plan. API access must be enabled on the resource — on by default for cases/plans created via this CLI; for dashboard-created ones, enable it in the Aximo dashboard settings. `trigger case run` returns a `sessionId` you can poll; `trigger plan run` returns a per-case breakdown.
 
 ### Uploads
 
@@ -335,17 +356,33 @@ The agent disables DPI-awareness and uses a calibrated scroll amount — if you
 
 Default `$AXIMO_HOME` is `~/.aximo` on macOS/Linux, `%USERPROFILE%\.aximo` on Windows. Override via the `AXIMO_HOME` env var.
 
-### Sandbox vs production
+> Devices are registered per-environment (see [Configuration](#configuration)) — a device registered against sandbox can't connect to production and vice versa.
+
+## MCP server
+
+`aximo mcp` runs a [Model Context Protocol](https://modelcontextprotocol.io) server over stdio, exposing your recorded sessions, screenshots, and test cases to MCP-capable agents (Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, …). The motivating use: let an agent read a finished session and generate a Playwright spec without you piping JSON between commands.
+
+It reuses the same credentials as every other command, so run `aximo configure` (or set `AXIMO_API_KEY`) first.
+
+**Claude Code** — one command:
 
 ```bash
-# Sandbox
-aximo configure --base-url https://aximo-sbx.autify.dev --api-key <sbx-key>
+claude mcp add aximo -- aximo mcp
+```
+
+**Other clients** — point them at the `aximo mcp` stdio command. Claude Desktop, Cursor, and Windsurf use the `mcpServers` key:
 
-# Production (default)
-aximo configure --base-url https://aximo.autify.com --api-key <prod-key>
+```json
+{
+  "mcpServers": {
+    "aximo": { "command": "aximo", "args": ["mcp"] }
+  }
+}
 ```
 
-Registrations are per-environment — a device registered against sandbox can't connect to production and vice versa.
+VS Code (Copilot agent mode) uses the same entry under a `servers` key in `.vscode/mcp.json`.
+
+The server exposes 15 tools: 10 read-only ones for inspecting sessions and cases (`aximo_get_session_timeline` is the load-bearing one for Playwright export) plus 5 that author content (create cases and 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.
 
 ## Agent Skills
 

package/dist/cli.js

@@ -5,7 +5,7 @@ import pkg from "../package.json" with { type: "json" };
 // is JSON-RPC.
 const args = process.argv.slice(2);
 if (args[0] === "mcp" && args.some((a) => a === "--help" || a === "-h")) {
-    process.stderr.write(`aximo mcp — stdio MCP server exposing read-only Aximo data.\n` +
+    process.stderr.write(`aximo mcp — stdio MCP server exposing Aximo data plus create operations.\n` +
         `\n` +
         `Wire into an MCP client (e.g. Claude Desktop, Claude Code) by pointing it\n` +
         `at this binary. Auth uses ~/.aximo/config.json (run \`aximo configure\`).\n` +
@@ -23,6 +23,8 @@ const main = defineCommand({
         configure: () => import("./commands/configure.js").then((m) => m.default),
         health: () => import("./commands/health/index.js").then((m) => m.default),
         session: () => import("./commands/session/index.js").then((m) => m.default),
+        case: () => import("./commands/case/index.js").then((m) => m.default),
+        plan: () => import("./commands/plan/index.js").then((m) => m.default),
         trigger: () => import("./commands/trigger/index.js").then((m) => m.default),
         device: () => import("./commands/device/index.js").then((m) => m.default),
         upload: () => import("./commands/upload/index.js").then((m) => m.default),

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

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

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

@@ -0,0 +1,86 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { runCaseCreate } from "./create.js";
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+const MIN = {
+    projectId: "proj-1",
+    scenario: "Open the login page and verify it loads",
+};
+describe("runCaseCreate", () => {
+    it("POSTs body and returns success envelope", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c1" }, { status: 201 });
+        }));
+        const result = await runCaseCreate({ ...MIN, type: "web", title: "Login" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.caseId).toBe("c1");
+        expect(seen).toMatchObject({
+            projectId: "proj-1",
+            scenario: "Open the login page and verify it loads",
+            type: "web",
+            title: "Login",
+        });
+    });
+    it("rejects missing projectId", async () => {
+        const result = await runCaseCreate({ scenario: "x" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects missing scenario", async () => {
+        const result = await runCaseCreate({ projectId: "p1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--json replaces individual flags and POSTs raw body", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c2" }, { status: 201 });
+        }));
+        const raw = JSON.stringify({ projectId: "p1", scenario: "raw", extra: true });
+        const result = await runCaseCreate({ json: raw });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ projectId: "p1", scenario: "raw", extra: true });
+    });
+    it("--dry-run returns request without calling API", async () => {
+        const result = await runCaseCreate({ ...MIN, dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.dryRun).toBe(true);
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases`);
+        }
+    });
+    it("returns unauthorized envelope when AXIMO_API_KEY unset", async () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        try {
+            const result = await runCaseCreate(MIN);
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error.code).toBe("unauthorized");
+        }
+        finally {
+            if (prev !== undefined)
+                process.env["AXIMO_API_KEY"] = prev;
+        }
+    });
+    it("maps 404 to not_found", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, () => HttpResponse.json({ error: "Project not found" }, { status: 404 })));
+        const result = await runCaseCreate(MIN);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+});

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

@@ -0,0 +1,53 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { CreateCaseResult, Envelope } from "../../types.js";
+export interface CreateCaseOptions {
+    projectId?: unknown;
+    scenario?: unknown;
+    type?: unknown;
+    title?: unknown;
+    description?: unknown;
+    format?: unknown;
+    startUrl?: unknown;
+    directoryId?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runCaseCreate(options: CreateCaseOptions, deps?: ClientDeps): Promise<Envelope<CreateCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "project-id": {
+        readonly type: "string";
+    };
+    readonly scenario: {
+        readonly type: "string";
+    };
+    readonly type: {
+        readonly type: "string";
+        readonly description: "web | mobile | desktop";
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly description: {
+        readonly type: "string";
+    };
+    readonly format: {
+        readonly type: "string";
+        readonly description: "gherkin | markdown | plain_text";
+    };
+    readonly "start-url": {
+        readonly type: "string";
+    };
+    readonly "directory-id": {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body (replaces individual flags)";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/case/create.js

@@ -0,0 +1,71 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../mutate.js";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { optionalString, requireString } from "../../validate.js";
+export async function runCaseCreate(options, deps) {
+    let body;
+    const override = resolveJsonOverride(options.json);
+    if (override && "error" in override)
+        return override.error;
+    if (override) {
+        body = override.body;
+    }
+    else {
+        try {
+            body = {
+                projectId: requireString("projectId", options.projectId),
+                scenario: requireString("scenario", options.scenario),
+                type: optionalString("type", options.type),
+                title: optionalString("title", options.title),
+                description: optionalString("description", options.description),
+                format: optionalString("format", options.format),
+                startUrl: optionalString("startUrl", options.startUrl),
+                directoryId: optionalString("directoryId", options.directoryId),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", "/api/cases", body);
+    }
+    try {
+        const res = await request("/api/cases", { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "create", description: "Create a test case" },
+    args: {
+        "project-id": { type: "string" },
+        scenario: { type: "string" },
+        type: { type: "string", description: "web | mobile | desktop" },
+        title: { type: "string" },
+        description: { type: "string" },
+        format: { type: "string", description: "gherkin | markdown | plain_text" },
+        "start-url": { type: "string" },
+        "directory-id": { type: "string" },
+        json: { type: "string", description: "Raw JSON request body (replaces individual flags)" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runCaseCreate({
+            projectId: args["project-id"],
+            scenario: args.scenario,
+            type: args.type,
+            title: args.title,
+            description: args.description,
+            format: args.format,
+            startUrl: args["start-url"],
+            directoryId: args["directory-id"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("citty").CommandDef<import("citty").ArgsDef>;
+export default _default;

package/dist/commands/case/index.js

@@ -0,0 +1,7 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "case", description: "Test case commands" },
+    subCommands: {
+        create: () => import("./create.js").then((m) => m.default),
+    },
+});

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

@@ -1,7 +1,7 @@
-import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { HttpResponse, TEST_BASE_URL, http, server } from "../../test-utils.js";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
 import { createMcpServer } from "./server.js";
 beforeAll(() => {
     process.env["AXIMO_API_KEY"] = "test-key";
@@ -24,7 +24,7 @@ async function connect() {
     };
 }
 describe("createMcpServer wiring", () => {
-    it("exposes all 10 tools through tools/list with valid JSON Schema", async () => {
+    it("exposes all 15 tools through tools/list with valid JSON Schema", async () => {
         const { client, cleanup } = await connect();
         try {
             const { tools } = await client.listTools();
@@ -39,6 +39,11 @@ describe("createMcpServer wiring", () => {
                 "aximo_list_cases",
                 "aximo_list_projects",
                 "aximo_list_sessions",
+                "aximo_create_case",
+                "aximo_create_plan",
+                "aximo_add_case_to_plan",
+                "aximo_remove_case_from_plan",
+                "aximo_save_session_as_case",
             ].sort());
             const timeline = tools.find((t) => t.name === "aximo_get_session_timeline");
             expect(timeline?.inputSchema?.required).toContain("sessionId");

package/dist/commands/mcp/tools.js

@@ -194,5 +194,75 @@ export function defineTools(deps = {}) {
                 return await request(`/api/cases/${encodeURIComponent(caseId)}`, {}, deps);
             }),
         },
+        {
+            name: "aximo_create_case",
+            title: "Create test case",
+            description: "Create a saved test case in a workspace. The case is API-enabled, so it can be triggered immediately. Returns the new caseId.",
+            inputSchema: {
+                projectId: z.string().uuid(),
+                scenario: z.string().min(1),
+                type: z.enum(["web", "mobile", "desktop"]).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(),
+                directoryId: z.string().uuid().optional(),
+            },
+            handler: async (input) => call(async () => {
+                return await request("/api/cases", { method: "POST", body: input }, deps);
+            }),
+        },
+        {
+            name: "aximo_create_plan",
+            title: "Create test plan",
+            description: "Create an empty test plan in a workspace. Add cases with aximo_add_case_to_plan, then run it. Returns the new planId.",
+            inputSchema: {
+                projectId: z.string().uuid(),
+                title: z.string().min(1).max(500),
+                description: z.string().optional(),
+            },
+            handler: async (input) => call(async () => {
+                return await request("/api/plans", { method: "POST", body: input }, deps);
+            }),
+        },
+        {
+            name: "aximo_add_case_to_plan",
+            title: "Add case to plan",
+            description: "Append a test case to the end of a plan. The case must belong to the same workspace as the plan.",
+            inputSchema: {
+                planId: z.string().uuid(),
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ planId, caseId }) => call(async () => {
+                return await request(`/api/plans/${encodeURIComponent(planId)}/cases`, { method: "POST", body: { caseId } }, deps);
+            }),
+        },
+        {
+            name: "aximo_remove_case_from_plan",
+            title: "Remove case from plan",
+            description: "Remove a test case from a plan. Idempotent.",
+            inputSchema: {
+                planId: z.string().uuid(),
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ planId, caseId }) => call(async () => {
+                return await request(`/api/plans/${encodeURIComponent(planId)}/cases/${encodeURIComponent(caseId)}`, { method: "DELETE" }, deps);
+            }),
+        },
+        {
+            name: "aximo_save_session_as_case",
+            title: "Save session as test case",
+            description: "Persist a finished agent session as a reusable test case and link the two. The session must be in a terminal state and not already linked to a case. The scenario defaults to the session summary. Returns the new caseId and projectId.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                title: z.string().min(1).max(500).optional(),
+                type: z.enum(["web", "mobile", "desktop"]).optional(),
+                scenario: z.string().min(1).optional(),
+                format: z.enum(["gherkin", "markdown", "plain_text"]).optional(),
+            },
+            handler: async ({ sessionId, ...body }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/save-as-case`, { method: "POST", body }, deps);
+            }),
+        },
     ];
 }

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

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
-import { HttpResponse, TEST_BASE_URL, http, server } from "../../test-utils.js";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
 import { defineTools } from "./tools.js";
 beforeAll(() => {
     process.env["AXIMO_API_KEY"] = "test-key";
@@ -31,6 +31,11 @@ describe("defineTools", () => {
             "aximo_get_session_snapshot",
             "aximo_list_cases",
             "aximo_get_case",
+            "aximo_create_case",
+            "aximo_create_plan",
+            "aximo_add_case_to_plan",
+            "aximo_remove_case_from_plan",
+            "aximo_save_session_as_case",
         ]);
     });
 });
@@ -203,3 +208,62 @@ describe("call() error mapping", () => {
         expect(payload.hint).toMatch(/AXIMO_BASE_URL/);
     });
 });
+describe("write tools", () => {
+    it("aximo_create_case POSTs the body to /api/cases", async () => {
+        let seen = null;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, async ({ request: req }) => {
+            seen = { method: req.method, body: await req.json() };
+            return HttpResponse.json({ success: true, caseId: "c1" }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_create_case");
+        const result = await tool.handler({ projectId: "p1", scenario: "do a thing", type: "web" });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual({ success: true, caseId: "c1" });
+        expect(seen.method).toBe("POST");
+        expect(seen.body).toMatchObject({ projectId: "p1", scenario: "do a thing", type: "web" });
+    });
+    it("aximo_create_plan POSTs the body to /api/plans", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/plans`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true, planId: "pl1" }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_create_plan");
+        const result = await tool.handler({ projectId: "p1", title: "Regression" });
+        expect(parsePayload(result)).toEqual({ success: true, planId: "pl1" });
+        expect(body).toMatchObject({ projectId: "p1", title: "Regression" });
+    });
+    it("aximo_add_case_to_plan POSTs caseId to the plan-cases path", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/plans/pl1/cases`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_add_case_to_plan");
+        const result = await tool.handler({ planId: "pl1", caseId: "c1" });
+        expect(parsePayload(result)).toEqual({ success: true });
+        expect(body).toEqual({ caseId: "c1" });
+    });
+    it("aximo_remove_case_from_plan DELETEs the plan-case path", async () => {
+        let method = null;
+        server.use(http.delete(`${TEST_BASE_URL}/api/plans/pl1/cases/c1`, ({ request: req }) => {
+            method = req.method;
+            return HttpResponse.json({ success: true });
+        }));
+        const tool = byName(defineTools(), "aximo_remove_case_from_plan");
+        const result = await tool.handler({ planId: "pl1", caseId: "c1" });
+        expect(parsePayload(result)).toEqual({ success: true });
+        expect(method).toBe("DELETE");
+    });
+    it("aximo_save_session_as_case POSTs to the save-as-case path without the id in the body", async () => {
+        let body;
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions/s1/save-as-case`, async ({ request: req }) => {
+            body = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c1", projectId: "p1" }, { status: 201 });
+        }));
+        const tool = byName(defineTools(), "aximo_save_session_as_case");
+        const result = await tool.handler({ sessionId: "s1", title: "Saved" });
+        expect(parsePayload(result)).toEqual({ success: true, caseId: "c1", projectId: "p1" });
+        expect(body).toEqual({ title: "Saved" });
+    });
+});