@autifyhq/aximo-cli 0.1.0

package/dist/commands/trigger/case/run.js

@@ -0,0 +1,81 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../../output.js";
+import { handleApiError } from "../../../errors.js";
+import { request } from "../../../client.js";
+import { requireId, optionalString, parsePlatform, parseFileType, parseStringList, } from "../../../validate.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../../mutate.js";
+export async function runTriggerCaseRun(options, deps) {
+    let caseId;
+    let body;
+    const override = resolveJsonOverride(options.json);
+    if (override && "error" in override)
+        return override.error;
+    try {
+        caseId = requireId("caseId", options.caseId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    if (override) {
+        body = override.body;
+    }
+    else {
+        try {
+            body = {
+                model: optionalString("model", options.model),
+                hostnameOverrideIds: parseStringList("hostnameOverrideIds", options.hostnameOverrideIds),
+                deviceArn: optionalString("deviceArn", options.deviceArn),
+                deviceName: optionalString("deviceName", options.deviceName),
+                platform: parsePlatform(options.platform),
+                uploadArn: optionalString("uploadArn", options.uploadArn),
+                uploadType: parseFileType(options.uploadType),
+                appName: optionalString("appName", options.appName),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    const path = `/api/triggers/cases/${encodeURIComponent(caseId)}/run`;
+    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: "run", description: "Trigger a case run" },
+    args: {
+        caseId: { type: "positional", description: "Case ID", required: true },
+        model: { type: "string" },
+        "hostname-override-ids": { type: "string", description: "comma-separated" },
+        "device-arn": { type: "string" },
+        "device-name": { type: "string" },
+        platform: { type: "string" },
+        "upload-arn": { type: "string" },
+        "upload-type": { type: "string" },
+        "app-name": { type: "string" },
+        json: { type: "string", description: "Raw JSON request body" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runTriggerCaseRun({
+            caseId: args.caseId,
+            model: args.model,
+            hostnameOverrideIds: args["hostname-override-ids"],
+            deviceArn: args["device-arn"],
+            deviceName: args["device-name"],
+            platform: args.platform,
+            uploadArn: args["upload-arn"],
+            uploadType: args["upload-type"],
+            appName: args["app-name"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

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

package/dist/commands/trigger/index.js

@@ -0,0 +1,8 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "trigger", description: "Trigger case/plan runs" },
+    subCommands: {
+        case: () => import("./case/index.js").then((m) => m.default),
+        plan: () => import("./plan/index.js").then((m) => m.default),
+    },
+});

package/dist/commands/trigger/plan/get.d.ts

@@ -0,0 +1,14 @@
+import type { Envelope, PlanRun } from "../../../types.js";
+import { type ClientDeps } from "../../../client.js";
+export declare function runTriggerPlanGet(planIdInput: unknown, planRunIdInput: unknown, deps?: ClientDeps): Promise<Envelope<PlanRun>>;
+declare const _default: import("citty").CommandDef<{
+    readonly planId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly planRunId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+}>;
+export default _default;

package/dist/commands/trigger/plan/get.js

@@ -0,0 +1,33 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../../output.js";
+import { handleApiError } from "../../../errors.js";
+import { request } from "../../../client.js";
+import { requireId } from "../../../validate.js";
+export async function runTriggerPlanGet(planIdInput, planRunIdInput, deps) {
+    let planId;
+    let planRunId;
+    try {
+        planId = requireId("planId", planIdInput);
+        planRunId = requireId("planRunId", planRunIdInput);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    try {
+        const res = await request(`/api/triggers/plans/${encodeURIComponent(planId)}/runs/${encodeURIComponent(planRunId)}`, {}, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "get", description: "Get status of a plan run" },
+    args: {
+        planId: { type: "positional", required: true },
+        planRunId: { type: "positional", required: true },
+    },
+    async run({ args }) {
+        printResult(await runTriggerPlanGet(args.planId, args.planRunId));
+    },
+});

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

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

package/dist/commands/trigger/plan/index.js

@@ -0,0 +1,8 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "plan", description: "Plan trigger commands" },
+    subCommands: {
+        run: () => import("./run.js").then((m) => m.default),
+        get: () => import("./get.js").then((m) => m.default),
+    },
+});

package/dist/commands/trigger/plan/run.d.ts

@@ -0,0 +1,33 @@
+import type { Envelope, PlanRunResult } from "../../../types.js";
+import { type ClientDeps } from "../../../client.js";
+import { type DryRunResult } from "../../../mutate.js";
+export interface TriggerPlanRunOptions {
+    planId?: unknown;
+    model?: unknown;
+    mobileConfig?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runTriggerPlanRun(options: TriggerPlanRunOptions, deps?: ClientDeps): Promise<Envelope<PlanRunResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly planId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly model: {
+        readonly type: "string";
+    };
+    readonly "mobile-config": {
+        readonly type: "string";
+        readonly description: "JSON object string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/trigger/plan/run.js

@@ -0,0 +1,63 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../../output.js";
+import { handleApiError } from "../../../errors.js";
+import { request } from "../../../client.js";
+import { requireId, optionalString, parseJsonObject } from "../../../validate.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../../mutate.js";
+export async function runTriggerPlanRun(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 = {
+                model: optionalString("model", options.model),
+                mobileConfig: parseJsonObject("mobileConfig", options.mobileConfig),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    const path = `/api/triggers/plans/${encodeURIComponent(planId)}/run`;
+    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: "run", description: "Trigger a plan run" },
+    args: {
+        planId: { type: "positional", required: true },
+        model: { type: "string" },
+        "mobile-config": { type: "string", description: "JSON object string" },
+        json: { type: "string", description: "Raw JSON request body" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runTriggerPlanRun({
+            planId: args.planId,
+            model: args.model,
+            mobileConfig: args["mobile-config"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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

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

package/dist/commands/trigger/trigger.test.js

@@ -0,0 +1,107 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runTriggerCaseRun } from "./case/run.js";
+import { runTriggerCaseGet } from "./case/get.js";
+import { runTriggerPlanRun } from "./plan/run.js";
+import { runTriggerPlanGet } from "./plan/get.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("trigger case", () => {
+    it("runs and returns sessionId", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/c1/run`, () => HttpResponse.json({ success: true, sessionId: "s1" }, { status: 201 })));
+        const result = await runTriggerCaseRun({ caseId: "c1", platform: "ANDROID" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.sessionId).toBe("s1");
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runTriggerCaseRun({});
+        expect(result.ok).toBe(false);
+    });
+    it("rejects caseId with forbidden chars", async () => {
+        const result = await runTriggerCaseRun({ caseId: "c1/../x" });
+        expect(result.ok).toBe(false);
+    });
+    it("--json replaces body", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/cases/c1/run`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, sessionId: "s1" }, { status: 201 });
+        }));
+        const result = await runTriggerCaseRun({ caseId: "c1", json: '{"foo":1}' });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ foo: 1 });
+    });
+    it("--dry-run skips API call", async () => {
+        const result = await runTriggerCaseRun({ caseId: "c1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/triggers/cases/c1/run`);
+        }
+    });
+    it("gets status by caseId + sessionId", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/cases/c1/sessions/s1`, () => HttpResponse.json({
+            id: "s1",
+            status: "completed",
+            platform: "IOS",
+            screenshotsCount: 3,
+        })));
+        const result = await runTriggerCaseGet("c1", "s1");
+        expect(result.ok).toBe(true);
+        if (result.ok)
+            expect(result.data.status).toBe("completed");
+    });
+    it("rejects empty sessionId", async () => {
+        const result = await runTriggerCaseGet("c1", "");
+        expect(result.ok).toBe(false);
+    });
+});
+describe("trigger plan", () => {
+    it("runs with mobileConfig JSON", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/triggers/plans/p1/run`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, planRunId: "pr1", totalCases: 2 }, { status: 201 });
+        }));
+        const result = await runTriggerPlanRun({
+            planId: "p1",
+            mobileConfig: '{"device":"ios"}',
+        });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.totalCases).toBe(2);
+        expect(seen).toMatchObject({ mobileConfig: { device: "ios" } });
+    });
+    it("plan run --dry-run skips call", async () => {
+        const result = await runTriggerPlanRun({ planId: "p1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("POST");
+        }
+    });
+    it("rejects invalid mobileConfig JSON", async () => {
+        const result = await runTriggerPlanRun({ planId: "p1", mobileConfig: "{bad" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("gets plan run", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/p1/runs/pr1`, () => HttpResponse.json({ id: "pr1", status: "running" })));
+        const result = await runTriggerPlanGet("p1", "pr1");
+        expect(result.ok).toBe(true);
+    });
+    it("maps 500 on plan get", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/p1/runs/pr1`, () => HttpResponse.json({ error: "boom" }, { status: 500 })));
+        const result = await runTriggerPlanGet("p1", "pr1");
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("api_error");
+            expect(result.error.retryable).toBe(true);
+        }
+    });
+});

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

@@ -0,0 +1,32 @@
+import type { Envelope, CreateUploadResult } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+export interface CreateUploadOptions {
+    fileName?: unknown;
+    fileSize?: unknown;
+    platform?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runUploadCreate(options: CreateUploadOptions, deps?: ClientDeps): Promise<Envelope<CreateUploadResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "file-name": {
+        readonly type: "string";
+    };
+    readonly "file-size": {
+        readonly type: "string";
+        readonly description: "File size in bytes";
+    };
+    readonly platform: {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/upload/create.js

@@ -0,0 +1,65 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireString, parsePlatform } from "../../validate.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../mutate.js";
+function parseFileSize(v) {
+    if (v === undefined || v === "")
+        return undefined;
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) {
+        throw new Error("fileSize must be a non-negative integer");
+    }
+    return n;
+}
+export async function runUploadCreate(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 = {
+                fileName: requireString("fileName", options.fileName),
+                fileSize: parseFileSize(options.fileSize),
+                platform: parsePlatform(options.platform),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", "/api/uploads", body);
+    }
+    try {
+        const res = await request("/api/uploads", { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "create", description: "Create an upload (returns presignedUrl)" },
+    args: {
+        "file-name": { type: "string" },
+        "file-size": { type: "string", description: "File size in bytes" },
+        platform: { type: "string" },
+        json: { type: "string", description: "Raw JSON request body" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runUploadCreate({
+            fileName: args["file-name"],
+            fileSize: args["file-size"],
+            platform: args.platform,
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

package/dist/commands/upload/get.d.ts

@@ -0,0 +1,10 @@
+import type { Envelope, Upload } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+export declare function runUploadGet(uploadIdInput: unknown, deps?: ClientDeps): Promise<Envelope<Upload>>;
+declare const _default: import("citty").CommandDef<{
+    readonly uploadId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+}>;
+export default _default;

package/dist/commands/upload/get.js

@@ -0,0 +1,30 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireId } from "../../validate.js";
+export async function runUploadGet(uploadIdInput, deps) {
+    let uploadId;
+    try {
+        uploadId = requireId("uploadId", uploadIdInput);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    try {
+        const res = await request(`/api/uploads/${encodeURIComponent(uploadId)}`, {}, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "get", description: "Get an upload by id" },
+    args: {
+        uploadId: { type: "positional", required: true },
+    },
+    async run({ args }) {
+        printResult(await runUploadGet(args.uploadId));
+    },
+});

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

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

package/dist/commands/upload/index.js

@@ -0,0 +1,11 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "upload", description: "Upload commands" },
+    subCommands: {
+        create: () => import("./create.js").then((m) => m.default),
+        list: () => import("./list.js").then((m) => m.default),
+        get: () => import("./get.js").then((m) => m.default),
+        put: () => import("./put.js").then((m) => m.default),
+        submit: () => import("./submit.js").then((m) => m.default),
+    },
+});

package/dist/commands/upload/list.d.ts

@@ -0,0 +1,15 @@
+import type { Envelope, Upload } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+export interface UploadListOptions {
+    fileType?: unknown;
+}
+export declare function runUploadList(options?: UploadListOptions, deps?: ClientDeps): Promise<Envelope<{
+    uploads: Upload[];
+}>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "file-type": {
+        readonly type: "string";
+        readonly description: "ANDROID_APP | IOS_APP";
+    };
+}>;
+export default _default;

package/dist/commands/upload/list.js

@@ -0,0 +1,31 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { parseFileType } from "../../validate.js";
+export async function runUploadList(options = {}, deps) {
+    let fileType;
+    try {
+        fileType = parseFileType(options.fileType);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    try {
+        const res = await request("/api/uploads", { query: { fileType } }, deps ?? {});
+        const uploads = res.uploads ?? [];
+        return formatSuccess({ uploads }, { total: uploads.length });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "list", description: "List uploads" },
+    args: {
+        "file-type": { type: "string", description: "ANDROID_APP | IOS_APP" },
+    },
+    async run({ args }) {
+        printResult(await runUploadList({ fileType: args["file-type"] }));
+    },
+});

package/dist/commands/upload/put.d.ts

@@ -0,0 +1,24 @@
+import type { Envelope, UploadPutResult } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+export interface UploadPutOptions {
+    uploadId?: unknown;
+    bytes?: Uint8Array | undefined;
+    dryRun?: unknown;
+}
+export declare function runUploadPut(options: UploadPutOptions, deps?: ClientDeps): Promise<Envelope<UploadPutResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly uploadId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly file: {
+        readonly type: "string";
+        readonly description: "Local path to the file";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/upload/put.js

@@ -0,0 +1,62 @@
+import { readFile } from "node:fs/promises";
+import { defineCommand } from "citty";
+import { formatSuccess, formatError, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireId } from "../../validate.js";
+import { dryRunEnvelope } from "../../mutate.js";
+export async function runUploadPut(options, deps) {
+    let uploadId;
+    try {
+        uploadId = requireId("uploadId", options.uploadId);
+        if (!options.dryRun && !options.bytes)
+            throw new Error("file bytes are required");
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    const path = `/api/uploads/${encodeURIComponent(uploadId)}`;
+    if (options.dryRun) {
+        return dryRunEnvelope("PUT", path);
+    }
+    try {
+        await request(path, {
+            method: "PUT",
+            rawBody: options.bytes ? new Blob([new Uint8Array(options.bytes)]) : undefined,
+            contentType: "application/octet-stream",
+            expectJson: false,
+        }, deps ?? {});
+        return formatSuccess({ success: true });
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "put", description: "Upload binary file bytes to the upload slot" },
+    args: {
+        uploadId: { type: "positional", required: true },
+        file: { type: "string", description: "Local path to the file" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        const dryRun = args["dry-run"];
+        if (dryRun) {
+            printResult(await runUploadPut({ uploadId: args.uploadId, dryRun: true }));
+            return;
+        }
+        if (!args.file) {
+            printResult(formatError("validation_error", "file is required", false));
+            return;
+        }
+        let bytes;
+        try {
+            bytes = await readFile(args.file);
+        }
+        catch (err) {
+            printResult(formatError("validation_error", `Cannot read file: ${args.file}`, false, err instanceof Error ? err.message : undefined));
+            return;
+        }
+        printResult(await runUploadPut({ uploadId: args.uploadId, bytes }));
+    },
+});