@autifyhq/aximo-cli 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,121 @@
+export interface SuccessMeta {
+    total?: number | undefined;
+}
+export interface SuccessEnvelope<T> {
+    ok: true;
+    data: T;
+    meta?: SuccessMeta | undefined;
+}
+export type ErrorCode = "unauthorized" | "rate_limited" | "not_found" | "validation_error" | "api_error";
+export interface ErrorEnvelope {
+    ok: false;
+    error: {
+        code: ErrorCode;
+        message: string;
+        hint?: string | undefined;
+        retryable: boolean;
+    };
+}
+export type Envelope<T> = SuccessEnvelope<T> | ErrorEnvelope;
+export type Platform = "ANDROID" | "IOS";
+export type FileType = "ANDROID_APP" | "IOS_APP";
+export interface HealthStatus {
+    status: string;
+}
+export interface CreateSessionInput {
+    title: string;
+    prompt: string;
+    projectId: string;
+    platform?: Platform | undefined;
+    model?: string | undefined;
+    startUrl?: string | undefined;
+    caseId?: string | undefined;
+    tags?: string[] | undefined;
+    deviceArn?: string | undefined;
+    deviceName?: string | undefined;
+    uploadArn?: string | undefined;
+    uploadType?: FileType | undefined;
+    appName?: string | undefined;
+    bundleId?: string | undefined;
+}
+export interface CreateSessionResult {
+    success: boolean;
+    sessionId: string;
+}
+export interface Session {
+    id: string;
+    title?: string | undefined;
+    status?: string | undefined;
+    [key: string]: unknown;
+}
+export interface CaseRunInput {
+    model?: string | undefined;
+    hostnameOverrideIds?: string[] | undefined;
+    deviceArn?: string | undefined;
+    deviceName?: string | undefined;
+    platform?: Platform | undefined;
+    uploadArn?: string | undefined;
+    uploadType?: FileType | undefined;
+    appName?: string | undefined;
+}
+export interface CaseRunResult {
+    success: boolean;
+    sessionId: string;
+}
+export interface CaseRunStatus {
+    id: string;
+    status: string;
+    result?: string | undefined;
+    platform: string;
+    screenshotsCount: number;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+}
+export interface PlanRunInput {
+    model?: string | undefined;
+    mobileConfig?: Record<string, unknown> | undefined;
+}
+export interface PlanRunResult {
+    success: boolean;
+    planRunId: string;
+    totalCases: number;
+}
+export interface PlanRun {
+    id: string;
+    status?: string | undefined;
+    [key: string]: unknown;
+}
+export interface Device {
+    arn?: string | undefined;
+    name?: string | undefined;
+    platform?: Platform | undefined;
+    [key: string]: unknown;
+}
+export interface CreateUploadInput {
+    fileName: string;
+    fileSize?: number | undefined;
+    platform?: Platform | undefined;
+}
+export interface CreateUploadResult {
+    uploadId: string;
+    presignedUrl: string;
+    fileType: FileType;
+}
+export interface Upload {
+    id?: string | undefined;
+    fileName?: string | undefined;
+    fileType?: FileType | undefined;
+    [key: string]: unknown;
+}
+export interface UploadPutResult {
+    success: boolean;
+}
+export interface UploadSubmitResult {
+    success: boolean;
+    workflowId: string;
+}
+export interface Project {
+    id?: string | undefined;
+    name?: string | undefined;
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// --- Envelope types ---
+export {};

package/dist/validate.d.ts

@@ -0,0 +1,14 @@
+import type { Platform, FileType } from "./types.js";
+export declare function optionalString(name: string, value: unknown): string | undefined;
+export declare function parseStringList(name: string, value: unknown): string[] | undefined;
+export declare function requireString(name: string, value: unknown): string;
+export declare function requireId(name: string, value: unknown): string;
+export declare function parsePlatform(value: unknown): Platform | undefined;
+export declare function parseFileType(value: unknown): FileType | undefined;
+export declare function parseTags(value: unknown): string[] | undefined;
+export declare const OPENAPI_URL = "https://aximo.autify.com/openapi.yaml";
+export declare class JsonBodyError extends Error {
+    constructor(message: string);
+}
+export declare function parseJsonBody(value: unknown): Record<string, unknown>;
+export declare function parseJsonObject(name: string, value: unknown): Record<string, unknown> | undefined;

package/dist/validate.js

@@ -0,0 +1,103 @@
+// Reject control characters in user-supplied identifiers (header injection guard).
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHAR_RE = /[\u0000-\u001f\u007f]/;
+export function optionalString(name, value) {
+    if (value === undefined || value === "")
+        return undefined;
+    return requireString(name, value);
+}
+export function parseStringList(name, value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string") {
+        throw new Error(`${name} must be a comma-separated string`);
+    }
+    const items = value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return items.length > 0 ? items : undefined;
+}
+export function requireString(name, value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${name} is required`);
+    }
+    if (CONTROL_CHAR_RE.test(value)) {
+        throw new Error(`${name} contains control characters`);
+    }
+    return value;
+}
+// Agents sometimes hallucinate IDs like "caseId?fields=name" or pre-URL-encoded
+// strings. requireId rejects characters that would smuggle query/path/escape
+// semantics into what should be an opaque identifier.
+const ID_FORBIDDEN_RE = /[?#%/\\\s]|\.\./;
+export function requireId(name, value) {
+    const str = requireString(name, value);
+    if (ID_FORBIDDEN_RE.test(str)) {
+        throw new Error(`${name} contains forbidden characters (?, #, %, /, \\, .., whitespace)`);
+    }
+    return str;
+}
+const PLATFORMS = new Set(["ANDROID", "IOS"]);
+export function parsePlatform(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string" || !PLATFORMS.has(value)) {
+        throw new Error(`platform must be ANDROID or IOS (got ${String(value)})`);
+    }
+    return value;
+}
+const FILE_TYPES = new Set(["ANDROID_APP", "IOS_APP"]);
+export function parseFileType(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string" || !FILE_TYPES.has(value)) {
+        throw new Error(`fileType must be ANDROID_APP or IOS_APP (got ${String(value)})`);
+    }
+    return value;
+}
+export function parseTags(value) {
+    return parseStringList("tags", value);
+}
+export const OPENAPI_URL = "https://aximo.autify.com/openapi.yaml";
+// Sentinel error used by handlers so the envelope can attach the OpenAPI hint
+// without losing the original parser message.
+export class JsonBodyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JsonBodyError";
+    }
+}
+export function parseJsonBody(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new JsonBodyError("--json must be a non-empty JSON string");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (err) {
+        throw new JsonBodyError(`--json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new JsonBodyError("--json must be a JSON object");
+    }
+    return parsed;
+}
+export function parseJsonObject(name, value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`${name} must be a JSON string`);
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (err) {
+        throw new Error(`${name} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${name} must be a JSON object`);
+    }
+    return parsed;
+}

package/dist/validate.test.d.ts

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

package/dist/validate.test.js

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { requireString, requireId, parsePlatform, parseFileType, parseTags, parseJsonObject, parseJsonBody, JsonBodyError, } from "./validate.js";
+describe("requireId", () => {
+    it("accepts plain IDs", () => {
+        expect(requireId("sessionId", "abc123_-")).toBe("abc123_-");
+    });
+    it.each([
+        ["caseId?fields=x"],
+        ["caseId#frag"],
+        ["caseId%20enc"],
+        ["foo/bar"],
+        ["foo\\bar"],
+        ["../etc"],
+        ["with space"],
+    ])("rejects %s", (value) => {
+        expect(() => requireId("id", value)).toThrow(/forbidden/);
+    });
+    it("rejects tab via control-char check", () => {
+        expect(() => requireId("id", "tab\there")).toThrow();
+    });
+    it("still requires non-empty", () => {
+        expect(() => requireId("id", "")).toThrow(/required/);
+    });
+});
+describe("parseJsonBody", () => {
+    it("parses object", () => {
+        expect(parseJsonBody('{"a":1}')).toEqual({ a: 1 });
+    });
+    it("rejects invalid JSON with JsonBodyError", () => {
+        expect(() => parseJsonBody("{bad")).toThrow(JsonBodyError);
+    });
+    it("rejects arrays", () => {
+        expect(() => parseJsonBody("[1]")).toThrow(/JSON object/);
+    });
+    it("rejects empty", () => {
+        expect(() => parseJsonBody("")).toThrow(JsonBodyError);
+    });
+});
+describe("requireString", () => {
+    it("returns the value when non-empty string", () => {
+        expect(requireString("x", "hello")).toBe("hello");
+    });
+    it("throws on empty", () => {
+        expect(() => requireString("x", "")).toThrow("x is required");
+    });
+    it("throws on non-string", () => {
+        expect(() => requireString("x", 42)).toThrow();
+    });
+    it("rejects control characters", () => {
+        expect(() => requireString("x", "a\u0000b")).toThrow("control");
+    });
+});
+describe("parsePlatform", () => {
+    it("accepts ANDROID / IOS", () => {
+        expect(parsePlatform("ANDROID")).toBe("ANDROID");
+        expect(parsePlatform("IOS")).toBe("IOS");
+    });
+    it("returns undefined for undefined or empty", () => {
+        expect(parsePlatform(undefined)).toBeUndefined();
+        expect(parsePlatform("")).toBeUndefined();
+    });
+    it("rejects invalid", () => {
+        expect(() => parsePlatform("WINDOWS")).toThrow();
+    });
+});
+describe("parseFileType", () => {
+    it("accepts valid values", () => {
+        expect(parseFileType("IOS_APP")).toBe("IOS_APP");
+    });
+    it("rejects invalid", () => {
+        expect(() => parseFileType("APK")).toThrow();
+    });
+});
+describe("parseTags", () => {
+    it("splits and trims", () => {
+        expect(parseTags("a, b ,c")).toEqual(["a", "b", "c"]);
+    });
+    it("returns undefined for empty", () => {
+        expect(parseTags("")).toBeUndefined();
+        expect(parseTags(",,")).toBeUndefined();
+    });
+});
+describe("parseJsonObject", () => {
+    it("parses object", () => {
+        expect(parseJsonObject("mobileConfig", '{"a":1}')).toEqual({ a: 1 });
+    });
+    it("rejects arrays", () => {
+        expect(() => parseJsonObject("x", "[1]")).toThrow("must be a JSON object");
+    });
+    it("rejects invalid JSON", () => {
+        expect(() => parseJsonObject("x", "{bad")).toThrow("not valid JSON");
+    });
+    it("returns undefined for empty", () => {
+        expect(parseJsonObject("x", "")).toBeUndefined();
+    });
+});

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@autifyhq/aximo-cli",
+  "version": "0.1.0",
+  "description": "Autify Aximo Command Line Interface (CLI)",
+  "keywords": [
+    "autify",
+    "aximo",
+    "cli"
+  ],
+  "homepage": "https://github.com/autifyhq/aximo-cli#readme",
+  "bugs": {
+    "url": "https://github.com/autifyhq/aximo-cli/issues"
+  },
+  "license": "MIT",
+  "author": "Autify",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/autifyhq/aximo-cli.git"
+  },
+  "bin": {
+    "aximo": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "citty": "0.2.2",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
+    "@secretlint/secretlint-rule-preset-recommend": "11.7.1",
+    "@types/node": "^25.6.0",
+    "@types/ws": "^8.18.0",
+    "@vitest/coverage-v8": "4.1.4",
+    "husky": "9.1.7",
+    "msw": "2.13.2",
+    "nano-staged": "1.0.2",
+    "oxfmt": "0.45.0",
+    "oxlint": "1.60.0",
+    "secretlint": "11.7.1",
+    "tsx": "4.21.0",
+    "typescript": "6.0.2",
+    "vitest": "4.1.4"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "cli": "tsx src/cli.ts",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "lint": "oxlint --deny-warnings --report-unused-disable-directives",
+    "lint:fix": "oxlint --fix --report-unused-disable-directives",
+    "test": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  }
+}