@autifyhq/aximo-cli 0.1.0 → 0.3.0

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

@@ -0,0 +1,89 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.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";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+async function connect() {
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const mcpServer = createMcpServer();
+    const client = new Client({ name: "test-client", version: "0.0.0" }, { capabilities: {} });
+    await Promise.all([mcpServer.connect(serverTransport), client.connect(clientTransport)]);
+    return {
+        client,
+        cleanup: async () => {
+            await client.close();
+            await mcpServer.close();
+        },
+    };
+}
+describe("createMcpServer wiring", () => {
+    it("exposes all 15 tools through tools/list with valid JSON Schema", async () => {
+        const { client, cleanup } = await connect();
+        try {
+            const { tools } = await client.listTools();
+            expect(tools.map((t) => t.name).sort()).toEqual([
+                "aximo_get_case",
+                "aximo_get_session",
+                "aximo_get_session_capture",
+                "aximo_get_session_snapshot",
+                "aximo_get_session_messages",
+                "aximo_get_session_screenshots",
+                "aximo_get_session_timeline",
+                "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");
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("dispatches a tools/call and returns the backend payload", async () => {
+        const sessionId = "77777777-7777-4777-9777-777777777777";
+        const payload = { sessionId, stepCount: 0, steps: [] };
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json(payload)));
+        const { client, cleanup } = await connect();
+        try {
+            const result = await client.callTool({
+                name: "aximo_get_session_timeline",
+                arguments: { sessionId },
+            });
+            expect(result.isError).toBeFalsy();
+            const content = result.content;
+            const text = content[0].text;
+            expect(JSON.parse(text)).toEqual(payload);
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("returns isError with a validation message when input fails the schema", async () => {
+        const { client, cleanup } = await connect();
+        try {
+            const result = await client.callTool({
+                name: "aximo_get_session_timeline",
+                arguments: { sessionId: "not-a-uuid" },
+            });
+            expect(result.isError).toBe(true);
+            const content = result.content;
+            expect(content[0].text).toMatch(/Invalid uuid|Input validation/);
+        }
+        finally {
+            await cleanup();
+        }
+    });
+});

package/dist/commands/mcp/tools.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { type ClientDeps } from "../../client.js";
+interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface Tool<TInput extends z.ZodRawShape = z.ZodRawShape> {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: TInput;
+    handler: (input: z.infer<z.ZodObject<TInput>>) => Promise<ToolResult>;
+}
+export declare function defineTools(deps?: ClientDeps): Tool[];
+export {};

package/dist/commands/mcp/tools.js

@@ -0,0 +1,268 @@
+import { z } from "zod";
+import { request } from "../../client.js";
+function ok(payload) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    };
+}
+function err(message, hint) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ error: message, ...(hint ? { hint } : {}) }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+async function call(fn) {
+    try {
+        return ok(await fn());
+    }
+    catch (e) {
+        if (!(e instanceof Error))
+            return err(String(e));
+        const status = e.status;
+        if (status === 401)
+            return err("Unauthorized: check AXIMO_API_KEY", "Run `aximo configure`.");
+        if (status === 403) {
+            return err(e.message || "Forbidden", "API key may not have access to this resource.");
+        }
+        if (status === 404)
+            return err(e.message || "Not found");
+        if (status === 429)
+            return err("Rate limited", "Aximo enforces a daily session limit.");
+        if (typeof status === "number")
+            return err(`HTTP ${status}: ${e.message}`);
+        if (e.message.startsWith("No API key configured")) {
+            return err("API key not configured", "Run `aximo configure` and restart the MCP server.");
+        }
+        const cause = e.cause;
+        const networkCode = cause?.code;
+        if (networkCode) {
+            return err(`Network error (${networkCode}): ${cause?.message ?? e.message}`, "Check AXIMO_BASE_URL and your network connection.");
+        }
+        return err(e.message);
+    }
+}
+function buildQuery(params) {
+    const out = {};
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== "")
+            out[k] = v;
+    }
+    return out;
+}
+export function defineTools(deps = {}) {
+    return [
+        {
+            name: "aximo_list_projects",
+            title: "List workspaces",
+            description: "List workspaces (projects) available to your organization. Use a project's id when listing sessions or cases.",
+            inputSchema: {},
+            handler: async () => call(async () => {
+                const res = await request("/api/organizations/projects", {}, deps);
+                return res;
+            }),
+        },
+        {
+            name: "aximo_list_sessions",
+            title: "List sessions",
+            description: "List sessions visible to your organization, newest first. Filter by projectId, caseId, or status. Paginated.",
+            inputSchema: {
+                projectId: z.string().uuid().optional(),
+                caseId: z.string().uuid().optional(),
+                status: z.string().optional(),
+                page: z.number().int().positive().optional(),
+                pageSize: z.number().int().positive().max(100).optional(),
+            },
+            handler: async (input) => call(async () => {
+                return await request("/api/sessions", { query: buildQuery(input) }, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session",
+            title: "Get session",
+            description: "Get session metadata, status, summary, observations, credits used, and counts (screenshots, tool calls).",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+            },
+            handler: async ({ sessionId }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}`, {}, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session_messages",
+            title: "Get session messages",
+            description: "Get the message timeline (tool calls, assistant text, user input) for a session. Cursor-paginated.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                cursor: z.string().optional(),
+                limit: z.number().int().positive().max(100).optional(),
+                order: z.enum(["asc", "desc"]).optional(),
+            },
+            handler: async ({ sessionId, ...rest }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, { query: buildQuery(rest) }, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session_screenshots",
+            title: "Get session screenshots",
+            description: "Get screenshots captured during a session, ordered by capture time. URLs are presigned (S3) or relative.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                cursor: z.string().optional(),
+                limit: z.number().int().positive().max(100).optional(),
+                order: z.enum(["asc", "desc"]).optional(),
+            },
+            handler: async ({ sessionId, ...rest }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/screenshots`, { query: buildQuery(rest) }, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session_timeline",
+            title: "Get session timeline",
+            description: "Get the merged step timeline: each step pairs a message (tool call, assistant turn, user input) with its screenshots. This is the recommended endpoint when generating a Playwright spec from a session.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+            },
+            handler: async ({ sessionId }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/timeline`, {}, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session_capture",
+            title: "Get session CDP capture",
+            description: "Get the CDP-derived capture metadata for a session: ordered timestamped events (actions, navigations, network XHR/fetch, console, exceptions, snapshot triggers), browser context, and post-session storage state. By default snapshots[] contains metadata only (id, url, title, domBytes, axBytes) — call aximo_get_session_snapshot to fetch a single snapshot's DOM/AX content, or pass includeSnapshots: 'full' to inline all of them (can be multi-MB). Cookie values are redacted by default — pass includeCookieValues: true only when you genuinely need them (e.g. to emit a Playwright context.storageState()). Returns 404 if the org doesn't have the CDP capture feature flag enabled or the session ran without capture.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                includeSnapshots: z
+                    .enum(["none", "metadata", "full"])
+                    .optional()
+                    .describe("Default 'metadata'. Use 'full' only when you need DOM/AX content inline."),
+                includeCookieValues: z
+                    .boolean()
+                    .optional()
+                    .describe("Default false. When true, cookie 'value' fields are returned unmasked — needed for Playwright storageState export."),
+            },
+            handler: async ({ sessionId, includeSnapshots, includeCookieValues }) => call(async () => {
+                const query = {};
+                if (includeSnapshots)
+                    query["includeSnapshots"] = includeSnapshots;
+                if (includeCookieValues)
+                    query["includeCookieValues"] = "true";
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/capture`, { query }, deps);
+            }),
+        },
+        {
+            name: "aximo_get_session_snapshot",
+            title: "Get one DOM+AX snapshot",
+            description: "Fetch a single DOM + accessibility-tree snapshot by id (from aximo_get_session_capture's snapshots[] list). Use this instead of pulling the whole capture blob when you only need one page's structure (a single snapshot can be 100 KB – 5 MB).",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                snapshotId: z.string().uuid(),
+            },
+            handler: async ({ sessionId, snapshotId }) => call(async () => {
+                return await request(`/api/sessions/${encodeURIComponent(sessionId)}/snapshots/${encodeURIComponent(snapshotId)}`, {}, deps);
+            }),
+        },
+        {
+            name: "aximo_list_cases",
+            title: "List test cases",
+            description: "List saved test cases for a workspace. Filter by type, search, or directory.",
+            inputSchema: {
+                projectId: z.string().uuid(),
+                type: z.enum(["web", "mobile"]).optional(),
+                search: z.string().optional(),
+                directoryId: z.string().optional(),
+                page: z.number().int().positive().optional(),
+                pageSize: z.number().int().positive().max(100).optional(),
+            },
+            handler: async (input) => call(async () => {
+                return await request("/api/cases", { query: buildQuery(input) }, 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.",
+            inputSchema: {
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ caseId }) => call(async () => {
+                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.d.ts

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

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

@@ -0,0 +1,269 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { defineTools } from "./tools.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());
+function byName(tools, name) {
+    const t = tools.find((x) => x.name === name);
+    if (!t)
+        throw new Error(`tool ${name} not found`);
+    return t;
+}
+function parsePayload(result) {
+    return JSON.parse(result.content[0].text);
+}
+describe("defineTools", () => {
+    it("registers the expected tool names", () => {
+        const names = defineTools().map((t) => t.name);
+        expect(names).toEqual([
+            "aximo_list_projects",
+            "aximo_list_sessions",
+            "aximo_get_session",
+            "aximo_get_session_messages",
+            "aximo_get_session_screenshots",
+            "aximo_get_session_timeline",
+            "aximo_get_session_capture",
+            "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",
+        ]);
+    });
+});
+describe("aximo_get_session_timeline", () => {
+    it("calls /api/sessions/:id/timeline and returns the JSON payload", async () => {
+        const sessionId = "11111111-1111-4111-9111-111111111111";
+        const payload = { sessionId, stepCount: 1, steps: [] };
+        let captured = null;
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, ({ request: req }) => {
+            captured = req.headers.get("x-api-key");
+            return HttpResponse.json(payload);
+        }));
+        const tool = byName(defineTools(), "aximo_get_session_timeline");
+        const result = await tool.handler({ sessionId });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(captured).toBe("test-key");
+    });
+    it("returns a structured error when the API returns 404", async () => {
+        const sessionId = "22222222-2222-4222-9222-222222222222";
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Session not found" }, { status: 404 })));
+        const tool = byName(defineTools(), "aximo_get_session_timeline");
+        const result = await tool.handler({ sessionId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result)).toMatchObject({ error: "Session not found" });
+    });
+    it("returns a structured error when the API returns 401", async () => {
+        const sessionId = "33333333-3333-4333-9333-333333333333";
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Unauthorized" }, { status: 401 })));
+        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).toMatch(/Unauthorized/);
+        expect(payload.hint).toMatch(/configure/);
+    });
+});
+describe("aximo_list_sessions", () => {
+    it("passes through query parameters", async () => {
+        let url = null;
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions`, ({ request: req }) => {
+            url = new URL(req.url);
+            return HttpResponse.json({
+                items: [],
+                totalCount: 0,
+                page: 1,
+                pageSize: 25,
+                totalPages: 0,
+            });
+        }));
+        const tool = byName(defineTools(), "aximo_list_sessions");
+        await tool.handler({
+            projectId: "44444444-4444-4444-8444-444444444444",
+            status: "succeeded",
+            page: 2,
+        });
+        expect(url).not.toBeNull();
+        expect(url.searchParams.get("projectId")).toBe("44444444-4444-4444-8444-444444444444");
+        expect(url.searchParams.get("status")).toBe("succeeded");
+        expect(url.searchParams.get("page")).toBe("2");
+    });
+});
+describe("aximo_get_case", () => {
+    it("returns the case scenario payload", async () => {
+        const caseId = "55555555-5555-4555-9555-555555555555";
+        const payload = {
+            id: caseId,
+            projectId: "p1",
+            type: "web",
+            title: "Login flow",
+            scenario: "Given I navigate to login\nThen I am logged in",
+            format: "gherkin",
+        };
+        server.use(http.get(`${TEST_BASE_URL}/api/cases/${caseId}`, () => HttpResponse.json(payload)));
+        const tool = byName(defineTools(), "aximo_get_case");
+        const result = await tool.handler({ caseId });
+        expect(parsePayload(result)).toEqual(payload);
+    });
+});
+describe("aximo_list_cases", () => {
+    it("requires projectId at schema time", () => {
+        const tool = byName(defineTools(), "aximo_list_cases");
+        // biome-ignore lint/suspicious/noExplicitAny: zod runtime check
+        const parsed = tool.inputSchema.projectId.safeParse(undefined);
+        expect(parsed.success).toBe(false);
+    });
+});
+describe("aximo_list_projects", () => {
+    it("calls /api/organizations/projects and returns the payload", async () => {
+        const payload = { projects: [{ id: "p1", name: "Default" }] };
+        let captured = null;
+        server.use(http.get(`${TEST_BASE_URL}/api/organizations/projects`, ({ request: req }) => {
+            captured = { method: req.method, url: req.url };
+            return HttpResponse.json(payload);
+        }));
+        const tool = byName(defineTools(), "aximo_list_projects");
+        const result = await tool.handler({});
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(captured).not.toBeNull();
+        expect(captured.method).toBe("GET");
+        expect(new URL(captured.url).pathname).toBe("/api/organizations/projects");
+    });
+});
+describe("call() error mapping", () => {
+    const sessionId = "66666666-6666-4666-9666-666666666666";
+    it("maps 403 with the original message and a hint", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Forbidden by policy" }, { status: 403 })));
+        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).toMatch(/Forbidden by policy|Forbidden/);
+        expect(payload.hint).toMatch(/access/i);
+    });
+    it("preserves the backend's 404 message instead of squashing to 'Not found'", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/sessions/${sessionId}/timeline`, () => HttpResponse.json({ error: "Session was archived" }, { status: 404 })));
+        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("Session was archived");
+    });
+    it("flags 429 with the rate-limit hint", 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);
+    });
+    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 })));
+        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).toMatch(/^HTTP 500/);
+    });
+    it("returns a config-error hint when the API key is missing mid-session", async () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        try {
+            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("API key not configured");
+            expect(payload.hint).toMatch(/aximo configure/);
+        }
+        finally {
+            process.env["AXIMO_API_KEY"] = prev;
+        }
+    });
+    it("surfaces network failures with code + remediation hint", async () => {
+        // MSW intercepts and reshapes thrown errors, so inject a fetch that throws
+        // a fetch-style network error directly via ClientDeps.
+        const networkErr = new TypeError("fetch failed");
+        networkErr.cause = {
+            code: "ENOTFOUND",
+            message: "getaddrinfo ENOTFOUND aximo.test",
+        };
+        const fetchImpl = (() => Promise.reject(networkErr));
+        const tool = byName(defineTools({ fetchImpl }), "aximo_get_session_timeline");
+        const result = await tool.handler({ sessionId });
+        expect(result.isError).toBe(true);
+        const payload = parsePayload(result);
+        expect(payload.error).toMatch(/Network error \(ENOTFOUND\)/);
+        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" });
+    });
+});