@autifyhq/aximo-cli 0.2.0 → 0.4.0

package/dist/commands/device/doctor.test.js

@@ -1,9 +1,9 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
-import { runDeviceDoctor } from "./doctor.js";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { relayProbeUrl, runDeviceDoctor } from "./doctor.js";
 let tempHome;
 beforeAll(() => {
     tempHome = mkdtempSync(join(tmpdir(), "aximo-doctor-"));
@@ -87,3 +87,9 @@ describe("runDeviceDoctor", () => {
         expect(findCheck(result.data.checks, "agent files")?.status).toBe("warn");
     });
 });
+describe("relayProbeUrl", () => {
+    it("targets the engine.io websocket endpoint, not the bare relay path", () => {
+        const wsBase = TEST_BASE_URL.replace(/^http/, "ws");
+        expect(relayProbeUrl()).toBe(`${wsBase}/devices/tunnel/?EIO=4&transport=websocket`);
+    });
+});

package/dist/commands/device/paths.d.ts

@@ -5,6 +5,7 @@ export declare function getPythonMarkerPath(): string;
 export declare function getDepsMarkerPath(): string;
 export declare function getCacheDir(): string;
 export declare function getRemoteLogPath(): string;
+export declare function getAgentCaBundlePath(): string;
 export declare function getAgentDir(): string;
 export declare function getAgentScriptPath(): string;
 export declare function getAgentRequirementsPath(): string;

package/dist/commands/device/paths.js

@@ -21,6 +21,9 @@ export function getCacheDir() {
 export function getRemoteLogPath() {
     return join(getAximoDir(), "remote.log");
 }
+export function getAgentCaBundlePath() {
+    return join(getAximoDir(), "agent-ca-bundle.pem");
+}
 export function getAgentDir() {
     return join(getAximoDir(), "agent");
 }

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 16 tools through tools/list with valid JSON Schema", async () => {
         const { client, cleanup } = await connect();
         try {
             const { tools } = await client.listTools();
@@ -39,6 +39,12 @@ describe("createMcpServer wiring", () => {
                 "aximo_list_cases",
                 "aximo_list_projects",
                 "aximo_list_sessions",
+                "aximo_create_case",
+                "aximo_delete_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,86 @@ 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_delete_case",
+            title: "Delete test case",
+            description: "Permanently delete a test case. It is removed from any plans it belongs to; past run sessions are kept but detached. This cannot be undone.",
+            inputSchema: {
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ caseId }) => call(async () => {
+                return await request(`/api/cases/${encodeURIComponent(caseId)}`, { method: "DELETE" }, 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,12 @@ describe("defineTools", () => {
             "aximo_get_session_snapshot",
             "aximo_list_cases",
             "aximo_get_case",
+            "aximo_create_case",
+            "aximo_delete_case",
+            "aximo_create_plan",
+            "aximo_add_case_to_plan",
+            "aximo_remove_case_from_plan",
+            "aximo_save_session_as_case",
         ]);
     });
 });
@@ -203,3 +209,73 @@ 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_delete_case DELETEs the case path", async () => {
+        let method = null;
+        server.use(http.delete(`${TEST_BASE_URL}/api/cases/c1`, ({ request: req }) => {
+            method = req.method;
+            return HttpResponse.json({ success: true });
+        }));
+        const tool = byName(defineTools(), "aximo_delete_case");
+        const result = await tool.handler({ 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" });
+    });
+});

package/dist/commands/plan/add-case.d.ts

@@ -0,0 +1,30 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { Envelope, PlanCaseResult } from "../../types.js";
+export interface PlanAddCaseOptions {
+    planId?: unknown;
+    caseId?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runPlanAddCase(options: PlanAddCaseOptions, deps?: ClientDeps): Promise<Envelope<PlanCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly planId: {
+        readonly type: "positional";
+        readonly description: "Plan ID";
+        readonly required: true;
+    };
+    readonly "case-id": {
+        readonly type: "string";
+        readonly description: "Case ID to add";
+    };
+    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/plan/add-case.js

@@ -0,0 +1,58 @@
+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 { requireId, requireString } from "../../validate.js";
+export async function runPlanAddCase(options, deps) {
+    let planId;
+    let body;
+    const override = resolveJsonOverride(options.json);
+    if (override && "error" in override)
+        return override.error;
+    try {
+        planId = requireId("planId", options.planId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    if (override) {
+        body = override.body;
+    }
+    else {
+        try {
+            body = { caseId: requireString("caseId", options.caseId) };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    const path = `/api/plans/${encodeURIComponent(planId)}/cases`;
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", path, body);
+    }
+    try {
+        const res = await request(path, { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "add-case", description: "Add a case to a plan" },
+    args: {
+        planId: { type: "positional", description: "Plan ID", required: true },
+        "case-id": { type: "string", description: "Case ID to add" },
+        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 runPlanAddCase({
+            planId: args.planId,
+            caseId: args["case-id"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

@@ -0,0 +1,31 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { CreatePlanResult, Envelope } from "../../types.js";
+export interface CreatePlanOptions {
+    projectId?: unknown;
+    title?: unknown;
+    description?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runPlanCreate(options: CreatePlanOptions, deps?: ClientDeps): Promise<Envelope<CreatePlanResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "project-id": {
+        readonly type: "string";
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly description: {
+        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/plan/create.js

@@ -0,0 +1,56 @@
+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 runPlanCreate(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),
+                title: requireString("title", options.title),
+                description: optionalString("description", options.description),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", "/api/plans", body);
+    }
+    try {
+        const res = await request("/api/plans", { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "create", description: "Create a test plan" },
+    args: {
+        "project-id": { type: "string" },
+        title: { type: "string" },
+        description: { 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 runPlanCreate({
+            projectId: args["project-id"],
+            title: args.title,
+            description: args.description,
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

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

package/dist/commands/plan/index.js

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

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

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

package/dist/commands/plan/plan.test.js

@@ -0,0 +1,104 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { runPlanAddCase } from "./add-case.js";
+import { runPlanCreate } from "./create.js";
+import { runPlanRemoveCase } from "./remove-case.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());
+describe("runPlanCreate", () => {
+    it("POSTs body and returns success envelope", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/plans`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, planId: "pl1" }, { status: 201 });
+        }));
+        const result = await runPlanCreate({ projectId: "proj-1", title: "Regression" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.planId).toBe("pl1");
+        expect(seen).toMatchObject({ projectId: "proj-1", title: "Regression" });
+    });
+    it("rejects missing title", async () => {
+        const result = await runPlanCreate({ projectId: "p1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--dry-run returns request without calling API", async () => {
+        const result = await runPlanCreate({ projectId: "p1", title: "t", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/plans`);
+        }
+    });
+});
+describe("runPlanAddCase", () => {
+    it("POSTs caseId to the plan-cases path", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/plans/pl1/cases`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true }, { status: 201 });
+        }));
+        const result = await runPlanAddCase({ planId: "pl1", caseId: "c1" });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ caseId: "c1" });
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runPlanAddCase({ planId: "pl1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects an injected plan id (requireId)", async () => {
+        const result = await runPlanAddCase({ planId: "pl1/../x", caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("maps 409 to validation_error", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/plans/pl1/cases`, () => HttpResponse.json({ error: "Case already in plan" }, { status: 409 })));
+        const result = await runPlanAddCase({ planId: "pl1", caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--dry-run returns request without calling API", async () => {
+        const result = await runPlanAddCase({ planId: "pl1", caseId: "c1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/plans/pl1/cases`);
+        }
+    });
+});
+describe("runPlanRemoveCase", () => {
+    it("DELETEs the plan-case path", async () => {
+        let called = false;
+        server.use(http.delete(`${TEST_BASE_URL}/api/plans/pl1/cases/c1`, () => {
+            called = true;
+            return HttpResponse.json({ success: true });
+        }));
+        const result = await runPlanRemoveCase({ planId: "pl1", caseId: "c1" });
+        expect(result.ok).toBe(true);
+        expect(called).toBe(true);
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runPlanRemoveCase({ planId: "pl1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--dry-run returns a DELETE request without calling API", async () => {
+        const result = await runPlanRemoveCase({ planId: "pl1", caseId: "c1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("DELETE");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/plans/pl1/cases/c1`);
+        }
+    });
+});

package/dist/commands/plan/remove-case.d.ts

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

package/dist/commands/plan/remove-case.js

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