@autifyhq/aximo-cli 0.2.0 → 0.4.0

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", [], [

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/desktop-server/setup-tls.test.d.ts

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

package/dist/desktop-server/setup-tls.test.js

@@ -0,0 +1,83 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveAgentSslCertFile, writeCertBundle } from "./setup.js";
+let tempDir;
+const savedEnv = {};
+beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "aximo-tls-"));
+    for (const key of ["SSL_CERT_FILE", "NODE_EXTRA_CA_CERTS", "AXIMO_HOME"]) {
+        savedEnv[key] = process.env[key];
+        delete process.env[key];
+    }
+    process.env["AXIMO_HOME"] = tempDir;
+});
+afterEach(() => {
+    for (const [key, value] of Object.entries(savedEnv)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    rmSync(tempDir, { recursive: true, force: true });
+    vi.doUnmock("node:child_process");
+    vi.resetModules();
+});
+describe("writeCertBundle", () => {
+    it("concatenates certifi roots and the custom CA into one bundle", () => {
+        const certifi = join(tempDir, "certifi.pem");
+        const customCa = join(tempDir, "ca.pem");
+        const out = join(tempDir, "bundle.pem");
+        writeFileSync(certifi, "-----CERTIFI ROOT-----\n");
+        writeFileSync(customCa, "-----AXIMO CA-----\n");
+        writeCertBundle(out, certifi, customCa);
+        const result = readFileSync(out, "utf-8");
+        expect(result).toContain("-----CERTIFI ROOT-----");
+        expect(result).toContain("-----AXIMO CA-----");
+        // certifi first, custom CA second, single trailing newline
+        expect(result).toBe("-----CERTIFI ROOT-----\n-----AXIMO CA-----\n");
+    });
+});
+describe("resolveAgentSslCertFile", () => {
+    it("respects an explicit SSL_CERT_FILE override", () => {
+        process.env["SSL_CERT_FILE"] = "/custom/bundle.pem";
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "ca.pem");
+        writeFileSync(join(tempDir, "ca.pem"), "ca");
+        expect(resolveAgentSslCertFile("/no/python")).toBe("/custom/bundle.pem");
+    });
+    it("returns undefined when no custom CA is configured (public-CA servers)", () => {
+        expect(resolveAgentSslCertFile("/no/python")).toBeUndefined();
+    });
+    it("returns undefined when NODE_EXTRA_CA_CERTS points at a missing file", () => {
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "does-not-exist.pem");
+        expect(resolveAgentSslCertFile("/no/python")).toBeUndefined();
+    });
+    it("degrades gracefully (no throw) when the embedded certifi store can't be located", () => {
+        process.env["NODE_EXTRA_CA_CERTS"] = join(tempDir, "ca.pem");
+        writeFileSync(join(tempDir, "ca.pem"), "-----AXIMO CA-----\n");
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        // A non-existent python makes `python -m certifi` fail, so no bundle is built.
+        expect(resolveAgentSslCertFile(join(tempDir, "no-such-python"))).toBeUndefined();
+        expect(errSpy).toHaveBeenCalled();
+        errSpy.mockRestore();
+    });
+    it("builds and returns the certifi+CA bundle when a custom CA and certifi store are present", async () => {
+        const certifiPath = join(tempDir, "certifi.pem");
+        const customCaPath = join(tempDir, "ca.pem");
+        writeFileSync(certifiPath, "-----CERTIFI ROOT-----\n");
+        writeFileSync(customCaPath, "-----AXIMO CA-----\n");
+        process.env["NODE_EXTRA_CA_CERTS"] = customCaPath;
+        // Stub `python -m certifi` so it resolves to the fixture certifi store above.
+        vi.resetModules();
+        vi.doMock("node:child_process", () => ({
+            spawn: vi.fn(),
+            spawnSync: vi.fn(() => ({ status: 0, stdout: `${certifiPath}\n` })),
+        }));
+        const { resolveAgentSslCertFile: resolve } = await import("./setup.js");
+        const bundlePath = resolve("/fake/python");
+        expect(bundlePath).toBe(join(tempDir, "agent-ca-bundle.pem"));
+        // The bundle is the certifi roots followed by the custom CA, in that order.
+        expect(readFileSync(bundlePath, "utf-8")).toBe("-----CERTIFI ROOT-----\n-----AXIMO CA-----\n");
+    });
+});

package/dist/desktop-server/setup.d.ts

@@ -15,5 +15,22 @@ interface RemoteOptions {
     deviceToken: string;
     deviceName: string;
 }
+/** Path to the embedded interpreter's certifi CA store, or undefined if unavailable. */
+export declare function embeddedCertifiPath(pythonPath: string): string | undefined;
+/** Write a combined trust store (certifi roots followed by the custom CA) to outPath. */
+export declare function writeCertBundle(outPath: string, certifiPath: string, customCaPath: string): void;
+/**
+ * Resolve the SSL_CERT_FILE for the Python desktop agent.
+ *
+ * The Node CLI trusts a custom CA (e.g. an on-prem self-signed server) via
+ * NODE_EXTRA_CA_CERTS, but Python ignores that variable, so the agent's wss://
+ * relay connection would fail verification. Mirror the trust by building a
+ * bundle of the embedded interpreter's certifi roots PLUS the custom CA and
+ * pointing SSL_CERT_FILE at it. SSL_CERT_FILE replaces the whole trust store, so
+ * the bundle must contain both — the custom CA alone would break every other TLS
+ * the agent does. No-op when no custom CA is configured (public-CA servers
+ * already verify via certifi).
+ */
+export declare function resolveAgentSslCertFile(pythonPath: string): string | undefined;
 export declare function startDesktopRemote(pythonPath: string, scriptPath: string, options: RemoteOptions): ChildProcess;
 export {};

package/dist/desktop-server/setup.js

@@ -5,7 +5,7 @@ import { arch as osArch, platform } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { getAximoDir, getCacheDir, getDepsMarkerPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "../commands/device/paths.js";
+import { getAgentCaBundlePath, getAximoDir, getCacheDir, getDepsMarkerPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, getRemoteLogPath, } from "../commands/device/paths.js";
 import { ensureAgent } from "./agent-sync.js";
 export const PYTHON_RELEASE = "20260414";
 export const PYTHON_VERSION = "3.12.13";
@@ -174,7 +174,58 @@ export async function ensurePythonReady(deps) {
         agentChanged: agent.changed,
     };
 }
+/** Path to the embedded interpreter's certifi CA store, or undefined if unavailable. */
+export function embeddedCertifiPath(pythonPath) {
+    const result = spawnSync(pythonPath, ["-m", "certifi"], { encoding: "utf-8" });
+    if (result.status !== 0)
+        return undefined;
+    const path = (result.stdout ?? "").trim();
+    return path && existsSync(path) ? path : undefined;
+}
+/** Write a combined trust store (certifi roots followed by the custom CA) to outPath. */
+export function writeCertBundle(outPath, certifiPath, customCaPath) {
+    const certifi = readFileSync(certifiPath, "utf-8");
+    const customCa = readFileSync(customCaPath, "utf-8");
+    writeFileSync(outPath, `${certifi.trimEnd()}\n${customCa.trimEnd()}\n`, { mode: 0o644 });
+}
+/**
+ * Resolve the SSL_CERT_FILE for the Python desktop agent.
+ *
+ * The Node CLI trusts a custom CA (e.g. an on-prem self-signed server) via
+ * NODE_EXTRA_CA_CERTS, but Python ignores that variable, so the agent's wss://
+ * relay connection would fail verification. Mirror the trust by building a
+ * bundle of the embedded interpreter's certifi roots PLUS the custom CA and
+ * pointing SSL_CERT_FILE at it. SSL_CERT_FILE replaces the whole trust store, so
+ * the bundle must contain both — the custom CA alone would break every other TLS
+ * the agent does. No-op when no custom CA is configured (public-CA servers
+ * already verify via certifi).
+ */
+export function resolveAgentSslCertFile(pythonPath) {
+    // Respect an explicit override — the user may already point Python at a bundle.
+    if (process.env["SSL_CERT_FILE"])
+        return process.env["SSL_CERT_FILE"];
+    const customCa = process.env["NODE_EXTRA_CA_CERTS"];
+    if (!customCa || !existsSync(customCa))
+        return undefined;
+    const certifiPath = embeddedCertifiPath(pythonPath);
+    if (!certifiPath) {
+        console.error("[remote] NODE_EXTRA_CA_CERTS is set but the embedded Python's certifi store " +
+            "could not be located; the desktop agent may fail TLS verification against a " +
+            "custom-CA server. Set SSL_CERT_FILE to a certifi+CA bundle to override.");
+        return undefined;
+    }
+    try {
+        const bundlePath = getAgentCaBundlePath();
+        writeCertBundle(bundlePath, certifiPath, customCa);
+        return bundlePath;
+    }
+    catch (err) {
+        console.error(`[remote] Failed to build the agent CA bundle: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
 export function startDesktopRemote(pythonPath, scriptPath, options) {
+    const sslCertFile = resolveAgentSslCertFile(pythonPath);
     const child = spawn(pythonPath, [scriptPath], {
         env: {
             ...process.env,
@@ -183,6 +234,7 @@ export function startDesktopRemote(pythonPath, scriptPath, options) {
             RELAY_URL: options.relayUrl,
             DEVICE_TOKEN: options.deviceToken,
             DEVICE_NAME: options.deviceName,
+            ...(sslCertFile ? { SSL_CERT_FILE: sslCertFile } : {}),
         },
         stdio: "pipe",
     });

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";

package/dist/index.js

@@ -1,17 +1,22 @@
-export { request, getApiKey, getBaseUrl } 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";

package/dist/types.d.ts

@@ -119,6 +119,46 @@ export interface Project {
     name?: string | undefined;
     [key: string]: unknown;
 }
+export interface CreateCaseInput {
+    projectId: string;
+    scenario: string;
+    type?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    format?: string | undefined;
+    startUrl?: string | undefined;
+    directoryId?: string | undefined;
+}
+export interface CreateCaseResult {
+    success: boolean;
+    caseId: string;
+}
+export interface DeleteCaseResult {
+    success: boolean;
+}
+export interface CreatePlanInput {
+    projectId: string;
+    title: string;
+    description?: string | undefined;
+}
+export interface CreatePlanResult {
+    success: boolean;
+    planId: string;
+}
+export interface PlanCaseResult {
+    success: boolean;
+}
+export interface SaveSessionAsCaseInput {
+    title?: string | undefined;
+    type?: string | undefined;
+    scenario?: string | undefined;
+    format?: string | undefined;
+}
+export interface SaveSessionAsCaseResult {
+    success: boolean;
+    caseId: string;
+    projectId: string;
+}
 export interface PaginatedList<T> {
     items: T[];
     totalCount: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autifyhq/aximo-cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Autify Aximo Command Line Interface (CLI)",
   "keywords": [
     "autify",