@autifyhq/aximo-cli 0.1.0 → 0.3.0

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"],
+        }));
+    },
+});

package/dist/commands/schema.js

@@ -1,6 +1,6 @@
 import { defineCommand } from "citty";
-import { formatSuccess, formatError, printResult } from "../output.js";
 import pkg from "../../package.json" with { type: "json" };
+import { formatError, formatSuccess, printResult } from "../output.js";
 function arg(name, type, description, required = false) {
     return { name, type, description, required };
 }
@@ -41,6 +41,45 @@ export function getSchema() {
                 cmd("get", "GET /api/sessions/{sessionId}", [
                     arg("sessionId", "positional", "Session ID", true),
                 ]),
+                cmd("save-as-case", "POST /api/sessions/{sessionId}/save-as-case", [
+                    arg("sessionId", "positional", "Session ID", true),
+                    arg("title", "string", ""),
+                    arg("type", "string", "web | mobile | desktop"),
+                    arg("scenario", "string", ""),
+                    arg("format", "string", "gherkin | markdown | plain_text"),
+                    ...MUTATE_ARGS,
+                ]),
+            ]),
+            cmd("case", "Test case commands", [], [
+                cmd("create", "POST /api/cases", [
+                    arg("project-id", "string", "Project ID"),
+                    arg("scenario", "string", "Test scenario text"),
+                    arg("type", "string", "web | mobile | desktop"),
+                    arg("title", "string", ""),
+                    arg("description", "string", ""),
+                    arg("format", "string", "gherkin | markdown | plain_text"),
+                    arg("start-url", "string", ""),
+                    arg("directory-id", "string", ""),
+                    ...MUTATE_ARGS,
+                ]),
+            ]),
+            cmd("plan", "Test plan commands", [], [
+                cmd("create", "POST /api/plans", [
+                    arg("project-id", "string", "Project ID"),
+                    arg("title", "string", "Plan title"),
+                    arg("description", "string", ""),
+                    ...MUTATE_ARGS,
+                ]),
+                cmd("add-case", "POST /api/plans/{planId}/cases", [
+                    arg("planId", "positional", "Plan ID", true),
+                    arg("case-id", "string", "Case ID to add"),
+                    ...MUTATE_ARGS,
+                ]),
+                cmd("remove-case", "DELETE /api/plans/{planId}/cases/{caseId}", [
+                    arg("planId", "positional", "Plan ID", true),
+                    arg("caseId", "positional", "Case ID", true),
+                    arg("dry-run", "boolean", "Validate and show request without calling API"),
+                ]),
             ]),
             cmd("trigger", "Trigger commands", [], [
                 cmd("case", "Case trigger commands", [], [
@@ -74,8 +113,8 @@ export function getSchema() {
                     ]),
                 ]),
             ]),
-            cmd("device", "Device commands", [], [
-                cmd("list", "GET /api/devices", [
+            cmd("device", "Device Farm mobile device listing (BYOD device commands are not exposed via schema)", [], [
+                cmd("list", "GET /api/devices — list Device Farm mobile devices (ANDROID/IOS)", [
                     arg("platform", "string", "ANDROID | IOS"),
                     arg("available-only", "boolean", ""),
                 ]),

package/dist/commands/session/index.js

@@ -4,5 +4,6 @@ export default defineCommand({
     subCommands: {
         create: () => import("./create.js").then((m) => m.default),
         get: () => import("./get.js").then((m) => m.default),
+        "save-as-case": () => import("./save-as-case.js").then((m) => m.default),
     },
 });

package/dist/commands/session/save-as-case.d.ts

@@ -0,0 +1,43 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { Envelope, SaveSessionAsCaseResult } from "../../types.js";
+export interface SessionSaveAsCaseOptions {
+    sessionId?: unknown;
+    title?: unknown;
+    type?: unknown;
+    scenario?: unknown;
+    format?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runSessionSaveAsCase(options: SessionSaveAsCaseOptions, deps?: ClientDeps): Promise<Envelope<SaveSessionAsCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly sessionId: {
+        readonly type: "positional";
+        readonly description: "Session ID";
+        readonly required: true;
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly type: {
+        readonly type: "string";
+        readonly description: "web | mobile | desktop";
+    };
+    readonly scenario: {
+        readonly type: "string";
+    };
+    readonly format: {
+        readonly type: "string";
+        readonly description: "gherkin | markdown | plain_text";
+    };
+    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/session/save-as-case.js

@@ -0,0 +1,69 @@
+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, requireId } from "../../validate.js";
+export async function runSessionSaveAsCase(options, deps) {
+    let sessionId;
+    let body;
+    const override = resolveJsonOverride(options.json);
+    if (override && "error" in override)
+        return override.error;
+    try {
+        sessionId = requireId("sessionId", options.sessionId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    if (override) {
+        body = override.body;
+    }
+    else {
+        try {
+            body = {
+                title: optionalString("title", options.title),
+                type: optionalString("type", options.type),
+                scenario: optionalString("scenario", options.scenario),
+                format: optionalString("format", options.format),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/save-as-case`;
+    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: "save-as-case", description: "Save a finished session as a test case" },
+    args: {
+        sessionId: { type: "positional", description: "Session ID", required: true },
+        title: { type: "string" },
+        type: { type: "string", description: "web | mobile | desktop" },
+        scenario: { type: "string" },
+        format: { type: "string", description: "gherkin | markdown | plain_text" },
+        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 runSessionSaveAsCase({
+            sessionId: args.sessionId,
+            title: args.title,
+            type: args.type,
+            scenario: args.scenario,
+            format: args.format,
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

package/dist/commands/session/save-as-case.test.d.ts

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

package/dist/commands/session/save-as-case.test.js

@@ -0,0 +1,58 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
+import { runSessionSaveAsCase } from "./save-as-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("runSessionSaveAsCase", () => {
+    it("POSTs to the save-as-case path and returns the new case", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions/s1/save-as-case`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c1", projectId: "p1" }, { status: 201 });
+        }));
+        const result = await runSessionSaveAsCase({ sessionId: "s1", title: "Saved" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data)) {
+            expect(result.data.caseId).toBe("c1");
+            expect(result.data.projectId).toBe("p1");
+        }
+        expect(seen).toMatchObject({ title: "Saved" });
+    });
+    it("works with no body fields (derives from session)", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions/s1/save-as-case`, () => HttpResponse.json({ success: true, caseId: "c2", projectId: "p1" }, { status: 201 })));
+        const result = await runSessionSaveAsCase({ sessionId: "s1" });
+        expect(result.ok).toBe(true);
+    });
+    it("rejects an empty sessionId", async () => {
+        const result = await runSessionSaveAsCase({ sessionId: "" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects an injected sessionId (requireId)", async () => {
+        const result = await runSessionSaveAsCase({ sessionId: "s1?x=1" });
+        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 runSessionSaveAsCase({ sessionId: "s1", 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/sessions/s1/save-as-case`);
+        }
+    });
+    it("maps 400 to validation_error", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions/s1/save-as-case`, () => HttpResponse.json({ error: "Session is still in progress" }, { status: 400 })));
+        const result = await runSessionSaveAsCase({ sessionId: "s1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+});

package/dist/index.d.ts

@@ -1,19 +1,24 @@
-export { request, getApiKey, getBaseUrl } from "./client.js";
 export type { ClientDeps, RequestOptions } from "./client.js";
-export { formatSuccess, formatError, printResult, validationError } from "./output.js";
-export { handleApiError } from "./errors.js";
+export { getApiKey, getBaseUrl, request } from "./client.js";
+export { runCaseCreate } from "./commands/case/create.js";
+export { runDeviceList } from "./commands/device/list.js";
 export { runHealthCheck } from "./commands/health/check.js";
+export { runPlanAddCase } from "./commands/plan/add-case.js";
+export { runPlanCreate } from "./commands/plan/create.js";
+export { runPlanRemoveCase } from "./commands/plan/remove-case.js";
 export { runProjectList } from "./commands/project/list.js";
-export { runDeviceList } from "./commands/device/list.js";
 export { runSessionCreate } from "./commands/session/create.js";
 export { runSessionGet } from "./commands/session/get.js";
-export { runTriggerCaseRun } from "./commands/trigger/case/run.js";
+export { runSessionSaveAsCase } from "./commands/session/save-as-case.js";
 export { runTriggerCaseGet } from "./commands/trigger/case/get.js";
-export { runTriggerPlanRun } from "./commands/trigger/plan/run.js";
+export { runTriggerCaseRun } from "./commands/trigger/case/run.js";
 export { runTriggerPlanGet } from "./commands/trigger/plan/get.js";
+export { runTriggerPlanRun } from "./commands/trigger/plan/run.js";
 export { runUploadCreate } from "./commands/upload/create.js";
-export { runUploadList } from "./commands/upload/list.js";
 export { runUploadGet } from "./commands/upload/get.js";
+export { runUploadList } from "./commands/upload/list.js";
 export { runUploadPut } from "./commands/upload/put.js";
 export { runUploadSubmit } from "./commands/upload/submit.js";
+export { handleApiError } from "./errors.js";
+export { formatError, formatSuccess, printResult, validationError } from "./output.js";
 export type * from "./types.js";