@autifyhq/aximo-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Autify Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,379 @@
+# @autifyhq/aximo-cli
+
+[![npm version](https://img.shields.io/npm/v/@autifyhq/aximo-cli)](https://www.npmjs.com/package/@autifyhq/aximo-cli)
+[![CI](https://github.com/autifyhq/aximo-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/autifyhq/aximo-cli/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+
+CLI for the [Autify Aximo API](https://aximo.autify.com/openapi.yaml), built for coding agents. Every command returns a JSON envelope (`{ok, data}` or `{ok: false, error}`) so output pipes cleanly into scripts and other tools.
+
+## Install
+
+```bash
+npm i -g @autifyhq/aximo-cli
+```
+
+## Quick Start
+
+```bash
+# 1. Configure credentials (interactive) — or set env vars, see Configuration below
+aximo configure
+
+# 2. Verify the connection
+aximo health check
+
+# 3. Run a desktop test session
+aximo project list
+aximo session create \
+    --project-id PROJECT_ID \
+    --title "Login test" \
+    --prompt "Go to https://example.com and verify the page loads."
+
+# 4. Poll session status
+aximo session get SESSION_ID
+```
+
+Get your API key from **Settings → API Keys** in the [Aximo dashboard](https://aximo.autify.com).
+
+## Configuration
+
+The CLI resolves each credential independently in this order:
+
+1. Value in `$AXIMO_HOME/config.json` (written by `aximo configure`)
+2. Environment variable
+3. Default (for base URL only: `https://aximo.autify.com`)
+
+| Variable         | Required | Default                    | Notes                                                        |
+| ---------------- | -------- | -------------------------- | ------------------------------------------------------------ |
+| `AXIMO_API_KEY`  | Yes      | —                          | Organization API key                                         |
+| `AXIMO_BASE_URL` | No       | `https://aximo.autify.com` | Override for sandbox / self-hosted                           |
+| `AXIMO_HOME`     | No       | `~/.aximo`                 | Data directory (config, device credentials, embedded Python) |
+
+### Using `aximo configure`
+
+```bash
+aximo configure                              # interactive prompts
+aximo configure --base-url URL --api-key KEY # non-interactive
+```
+
+The interactive flow prompts first for the base URL (empty → keep existing, else falls back to the Aximo default), then for the API key (empty → keep existing; errors if nothing is saved). Config is written to `$AXIMO_HOME/config.json` with mode `0600`. To change sandbox/prod, re-run `aximo configure` and enter a new URL.
+
+### Using environment variables
+
+If you'd rather keep credentials out of a file (CI, ephemeral shells), set env vars:
+
+```bash
+# macOS / Linux
+export AXIMO_API_KEY=your-api-key
+export AXIMO_BASE_URL=https://aximo-sbx.autify.dev   # optional, prod is the default
+
+# Windows (PowerShell, persistent)
+[Environment]::SetEnvironmentVariable("AXIMO_API_KEY", "your-api-key", "User")
+[Environment]::SetEnvironmentVariable("AXIMO_BASE_URL", "https://aximo-sbx.autify.dev", "User")
+```
+
+## Commands
+
+Run `aximo <command> --help` for detailed usage. `aximo schema [command.path]` returns machine-readable argument introspection (e.g. `aximo schema session.create`).
+
+| Command                   | Description                                          |
+| ------------------------- | ---------------------------------------------------- |
+| `aximo configure`         | Save credentials to `$AXIMO_HOME/config.json`        |
+| `aximo health check`      | Check API reachability                               |
+| `aximo project list`      | List organization projects                           |
+| `aximo session create`    | Create and queue a test session                      |
+| `aximo session get`       | Get session status                                   |
+| `aximo trigger case run`  | Trigger a dashboard-created test case                |
+| `aximo trigger case get`  | Get triggered case status                            |
+| `aximo trigger plan run`  | Trigger a test plan                                  |
+| `aximo trigger plan get`  | Get plan run status                                  |
+| `aximo upload create`     | Create an upload slot for an APK/IPA                 |
+| `aximo upload list`       | List previously uploaded apps                        |
+| `aximo upload get`        | Poll upload processing status                        |
+| `aximo upload put`        | Upload binary file to the slot                       |
+| `aximo upload submit`     | Finalize upload and trigger processing               |
+| `aximo device list`       | List mobile devices from Device Farm                 |
+| `aximo device setup`      | First-time BYOD onboarding (API + Python + register) |
+| `aximo device register`   | Register this machine as a BYOD device               |
+| `aximo device connect`    | Start the BYOD agent and connect to the relay        |
+| `aximo device status`     | List your organization's BYOD devices                |
+| `aximo device ping`       | Check your BYOD device's server-side status          |
+| `aximo device doctor`     | Diagnose BYOD setup (env, Python, relay, status)     |
+| `aximo device logs`       | Show the BYOD agent log                              |
+| `aximo device unregister` | Remove a BYOD device server-side + clear local creds |
+| `aximo device reset`      | Remove BYOD local state (Python, deps, credentials)  |
+| `aximo schema`            | Show CLI surface as JSON                             |
+
+Mutating commands support `--json '<raw body>'` for direct OpenAPI payloads and `--dry-run` to preview requests without executing.
+
+### Health
+
+```bash
+aximo health check
+```
+
+Returns `{ok: true, data: {status: "ok"}}` when the API is reachable and your API key is valid.
+
+### Projects
+
+```bash
+aximo project list
+```
+
+Lists active workspaces in your organization. Grab the `id` to pass as `--project-id` for session creation.
+
+### Sessions
+
+```bash
+aximo session create --title <t> --prompt <p> --project-id <id> \
+  [--platform ANDROID|IOS] [--model <m>] [--start-url <url>] \
+  [--case-id <id>] [--tags <comma-separated>] \
+  [--device-arn <arn>] [--device-name <name>] \
+  [--upload-arn <arn>] [--upload-type ANDROID_APP|IOS_APP] \
+  [--app-name <name>] [--bundle-id <id>] \
+  [--json '<body>'] [--dry-run]
+
+aximo session get <sessionId>
+```
+
+Desktop sessions default to `platform=desktop`, `model=sonnet`. Mobile sessions require both `--device-arn` and `--upload-arn`.
+
+### Triggers (test cases and plans)
+
+```bash
+aximo trigger case run  <caseId> [...]
+aximo trigger case get  <caseId> <sessionId>
+aximo trigger plan run  <planId> [...]
+aximo trigger plan get  <planId> <planRunId>
+```
+
+Triggers dashboard-created test cases or plans. API access must be enabled in the Aximo dashboard settings. `trigger case run` returns a `sessionId` you can poll; `trigger plan run` returns per-case breakdown.
+
+### Uploads
+
+```bash
+aximo upload create --file-name <name> [--file-size <bytes>] [--platform ANDROID|IOS]
+aximo upload put    <uploadId> --file <path>
+aximo upload submit <uploadId>
+aximo upload get    <uploadId>
+aximo upload list   [--file-type ANDROID_APP|IOS_APP]
+```
+
+Typical flow: `create` → `put` (sends binary to the presigned URL) → `submit` → poll `get` until `status=succeeded` → extract `uploadArn` for mobile sessions. `upload list` auto-re-uploads expired Device Farm entries.
+
+### Schema
+
+```bash
+aximo schema               # all commands
+aximo schema session.create # one command's arg schema
+```
+
+Machine-readable JSON view of the CLI surface — used by agent skills for discovery.
+
+## Device (BYOD — Bring Your Own Device)
+
+The `device` commands let you register your own desktop as a test execution target. Aximo's agent controls it remotely over WebSocket to run tests against apps on your machine (useful when tests need access to your LAN, VPN, or a specific desktop environment).
+
+Terminology note: **`aximo device list` returns mobile devices** from Device Farm; **`aximo device status` returns BYOD devices** you've registered. Don't confuse the two.
+
+### Prerequisites
+
+- **Node.js 20+**, plus `aximo-cli` installed globally (see [Install](#install)).
+- **An Aximo API key**, configured via `aximo configure` or env vars.
+- **Active desktop session** — the agent uses `pyautogui` for screenshots and input, so the screen must be unlocked and awake while tests run.
+- **Outbound WebSocket to port 443** — most corporate firewalls allow this; if yours doesn't, see [Troubleshooting](#byod-troubleshooting).
+
+> Python is **not** a prerequisite. On first `connect` (or via `device setup`), the CLI downloads a self-contained CPython build into `$AXIMO_HOME/python/` (~35 MB download, ~130 MB installed) and installs the required packages. Your system Python is untouched.
+
+### First-time setup
+
+One-command onboarding:
+
+```bash
+aximo device setup --name "My Windows PC"
+```
+
+This verifies API reachability, installs the embedded Python runtime, installs Python dependencies, and registers this machine. If the device is already registered locally, it skips registration and reports `alreadyRegistered: true`.
+
+Or step-by-step, if you'd rather see each stage:
+
+```bash
+aximo health check                          # confirm credentials + connectivity
+aximo device register --name "My Windows PC"  # creates server-side device, writes $AXIMO_HOME/device.json (0600)
+aximo device connect                         # installs embedded Python on first run, then connects
+```
+
+On success, `device connect` prints something like:
+
+```
+Preparing Python environment...
+Fetching embedded Python 3.12.13 (x86_64-pc-windows-msvc)...
+Extracting...
+Installing Python dependencies...
+Python ready: C:\Users\<you>\.aximo\python\python.exe
+Agent version: 8f3a1c04
+Starting desktop agent, relay: wss://aximo.autify.com/devices/tunnel
+Device "My Windows PC" is online. Press Ctrl+C to disconnect.
+```
+
+Subsequent `connect` runs skip the Python download and dep install — they re-run only when the server-hosted agent script changes.
+
+### Daily use
+
+```bash
+aximo device connect     # start the agent; keep the terminal open while tests run
+# Ctrl+C to disconnect
+```
+
+Your device shows up in the Aximo UI under **Settings → Devices** with status `online` while connected. In the session form, pick your device as the execution target; Aximo routes the agent's actions through the tunnel to your machine.
+
+### Managing devices
+
+```bash
+aximo device status                       # list YOUR BYOD devices, with online/offline + lastSeenAt
+aximo device ping                         # server-side status for the locally registered device
+aximo device ping --device-id DEVICE_ID   # same, for a specific device
+aximo device unregister                   # delete server-side + clear local credentials
+aximo device unregister --device-id DEVICE_ID  # unregister an orphaned device (no local creds)
+```
+
+`device ping` returns what the server knows, including `lastSeenAgoSeconds` and the HTTP round-trip `latencyMs`. It does **not** round-trip through the relay, so a passing ping tells you "the server thinks this device is online," not "the local agent is responding right now."
+
+### Re-registering
+
+`aximo device register` refuses to overwrite an existing local registration. To move a registration to a different device name:
+
+```bash
+aximo device unregister                      # clean up the old one server-side
+aximo device register --name "New Name"
+```
+
+If you've lost the original local credentials and need to delete the orphaned server-side device:
+
+```bash
+aximo device status                          # find its deviceId
+aximo device unregister --device-id DEVICE_ID
+```
+
+Or use `aximo device register --force` — but that silently orphans the previous server-side device, so the explicit `unregister` + `register` path is safer.
+
+### Inspecting and resetting local state
+
+```bash
+aximo device logs                          # tail the last 50 lines of the agent log
+aximo device logs --follow                 # stream new lines (not JSON-enveloped; human use)
+aximo device logs --path                   # print the log file path and exit
+aximo device logs --clear                  # truncate the log
+
+aximo device doctor                        # run all checks: env, API, Python, relay, status
+aximo device doctor --skip-relay           # skip WebSocket reachability probe
+aximo device doctor --skip-api             # offline checks only
+
+aximo device reset --python                # remove embedded Python + its cache
+aximo device reset --deps                  # reinstall deps on next setup
+aximo device reset --device                # delete local credentials (server-side stays; run `unregister` first to also delete there)
+aximo device reset --all                   # wipe $AXIMO_HOME entirely
+```
+
+`doctor` is the first thing to run when anything's off — it covers the whole stack in one shot.
+
+### BYOD troubleshooting
+
+**"No API key configured."**
+Either run `aximo configure`, or set `AXIMO_API_KEY` in your environment. Verify with `echo $AXIMO_API_KEY` (or `echo $env:AXIMO_API_KEY` on PowerShell).
+
+**"Authentication failed."**
+Your device token is invalid (deleted server-side, or the server URL changed). Clean up and re-register:
+
+```bash
+aximo device unregister
+aximo device register --name "My PC"
+aximo device connect
+```
+
+**"Disconnected. Reconnecting in Xs..."**
+Normal for brief network blips — the agent retries with exponential backoff (1 s → 30 s max). If it keeps failing:
+
+- Check your internet connection.
+- Confirm `AXIMO_BASE_URL` is correct and reachable: `aximo health check`.
+- Confirm outbound WebSocket on 443 isn't blocked: `aximo device doctor` runs a handshake probe.
+
+**Python download or pip install fails (corporate proxy).**
+The embedded Python is fetched from `github.com/astral-sh/python-build-standalone/releases`; packages come from PyPI. Behind a proxy:
+
+```bash
+# macOS / Linux
+~/.aximo/python/bin/python3 -m pip config set global.proxy http://your-proxy:port
+
+# Windows
+%USERPROFILE%\.aximo\python\python.exe -m pip config set global.proxy http://your-proxy:port
+```
+
+To retry from a clean slate: `aximo device reset --python && aximo device setup`.
+
+**Device shows online, but tests fail on screenshot / click.**
+Your screen is locked or the session is inactive. `pyautogui` needs an active desktop session.
+
+**macOS: actions seem to do nothing.**
+System Settings → Privacy & Security → Accessibility and Screen Recording — both need to be granted to the terminal (or the Python binary that spawned).
+
+**Linux: "missing: scrot, xclip".**
+`aximo device doctor` flags this when the tools aren't on PATH. Install via your package manager (`apt install scrot xclip` on Debian/Ubuntu).
+
+**Windows: coordinates off / scrolling too fast or too slow.**
+The agent disables DPI-awareness and uses a calibrated scroll amount — if you still see mismatches, run `aximo device doctor` and share the output.
+
+### Environment & file layout
+
+| Path                              | Mode | Purpose                                                  |
+| --------------------------------- | ---- | -------------------------------------------------------- |
+| `$AXIMO_HOME/config.json`         | 0600 | CLI credentials (from `aximo configure`)                 |
+| `$AXIMO_HOME/device.json`         | 0600 | BYOD registration + device token                         |
+| `$AXIMO_HOME/agent/remote.py`     | 0644 | Python agent (server-synced)                             |
+| `$AXIMO_HOME/agent/manifest.json` | 0644 | Version + sha256 of cached agent files                   |
+| `$AXIMO_HOME/python/`             | —    | Embedded CPython runtime                                 |
+| `$AXIMO_HOME/remote.log`          | —    | Agent log (rotate/clear via `aximo device logs --clear`) |
+
+Default `$AXIMO_HOME` is `~/.aximo` on macOS/Linux, `%USERPROFILE%\.aximo` on Windows. Override via the `AXIMO_HOME` env var.
+
+### Sandbox vs production
+
+```bash
+# Sandbox
+aximo configure --base-url https://aximo-sbx.autify.dev --api-key <sbx-key>
+
+# Production (default)
+aximo configure --base-url https://aximo.autify.com --api-key <prod-key>
+```
+
+Registrations are per-environment — a device registered against sandbox can't connect to production and vice versa.
+
+## Agent Skills
+
+Ships with an [agent skill](https://skills.sh/). Once installed, the agent discovers commands via `aximo schema` and follows workflows in `skills/aximo-cli/`.
+
+```bash
+npx skills add autifyhq/aximo-cli
+```
+
+See [commands reference](./skills/aximo-cli/references/commands.md) and [workflows](./skills/aximo-cli/references/workflows.md) for the agent-oriented docs.
+
+## Contributing
+
+### Requirements
+
+- [mise](https://mise.jdx.dev/)
+
+### Preparation
+
+```bash
+pnpm install
+pnpm run cli -- health check
+```
+
+### Release Process
+
+Automated via [release-please](https://github.com/googleapis/release-please):
+
+1. Merge commits to `main` with Conventional Commit messages
+2. release-please creates/updates a Release PR with CHANGELOG.md
+3. Merge the Release PR to publish a GitHub Release and npm package

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import pkg from "../package.json" with { type: "json" };
+const main = defineCommand({
+    meta: {
+        name: "aximo",
+        version: pkg.version,
+        description: "Autify Aximo CLI for coding agents",
+    },
+    subCommands: {
+        configure: () => import("./commands/configure.js").then((m) => m.default),
+        health: () => import("./commands/health/index.js").then((m) => m.default),
+        session: () => import("./commands/session/index.js").then((m) => m.default),
+        trigger: () => import("./commands/trigger/index.js").then((m) => m.default),
+        device: () => import("./commands/device/index.js").then((m) => m.default),
+        upload: () => import("./commands/upload/index.js").then((m) => m.default),
+        project: () => import("./commands/project/index.js").then((m) => m.default),
+        schema: () => import("./commands/schema.js").then((m) => m.default),
+    },
+});
+runMain(main);

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_BASE_URL = "https://aximo.autify.com";
+export declare function getApiKey(): string;
+export declare function getBaseUrl(): string;
+export interface RequestOptions {
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    rawBody?: BodyInit | undefined;
+    contentType?: string | undefined;
+    expectJson?: boolean;
+}
+export interface ClientDeps {
+    apiKey?: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+}
+export declare function request<T>(path: string, options?: RequestOptions, deps?: ClientDeps): Promise<T>;
+export declare function requestBuffer(path: string, deps?: ClientDeps): Promise<Buffer>;

package/dist/client.js

@@ -0,0 +1,90 @@
+import { loadConfig } from "./config.js";
+export const DEFAULT_BASE_URL = "https://aximo.autify.com";
+export function getApiKey() {
+    const config = loadConfig();
+    const key = config.apiKey ?? process.env["AXIMO_API_KEY"];
+    if (!key) {
+        throw new Error("No API key configured. Run `aximo configure`, set AXIMO_API_KEY in your environment, or use `node --env-file=.env`.");
+    }
+    return key;
+}
+export function getBaseUrl() {
+    const config = loadConfig();
+    const raw = config.baseUrl ?? process.env["AXIMO_BASE_URL"] ?? DEFAULT_BASE_URL;
+    return raw.replace(/\/+$/, "");
+}
+function httpError(status, message, retryAfter) {
+    const err = Object.assign(new Error(message), { status });
+    if (retryAfter !== undefined)
+        err.retryAfter = retryAfter;
+    return err;
+}
+async function errorMessage(res) {
+    const text = await res.text().catch(() => "");
+    if (!text)
+        return res.statusText || `HTTP ${res.status}`;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === "string")
+            return parsed.error;
+        if (typeof parsed.message === "string")
+            return parsed.message;
+    }
+    catch {
+        // fall through
+    }
+    return text;
+}
+function buildUrl(baseUrl, path, query) {
+    const url = new URL(path.startsWith("/") ? path : `/${path}`, `${baseUrl}/`);
+    if (query) {
+        for (const [k, v] of Object.entries(query)) {
+            if (v === undefined)
+                continue;
+            url.searchParams.set(k, String(v));
+        }
+    }
+    return url.toString();
+}
+export async function request(path, options = {}, deps = {}) {
+    const apiKey = deps.apiKey ?? getApiKey();
+    const baseUrl = deps.baseUrl ?? getBaseUrl();
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const method = options.method ?? "GET";
+    const url = buildUrl(baseUrl, path, options.query);
+    const headers = { "x-api-key": apiKey };
+    let body;
+    if (options.rawBody !== undefined) {
+        body = options.rawBody;
+        if (options.contentType)
+            headers["Content-Type"] = options.contentType;
+    }
+    else if (options.body !== undefined) {
+        headers["Content-Type"] = "application/json";
+        body = JSON.stringify(options.body);
+    }
+    const res = await fetchImpl(url, { method, headers, ...(body !== undefined ? { body } : {}) });
+    if (!res.ok) {
+        const retryAfter = res.headers.get("retry-after") ?? undefined;
+        throw httpError(res.status, await errorMessage(res), retryAfter);
+    }
+    if (options.expectJson === false) {
+        return undefined;
+    }
+    const text = await res.text();
+    if (!text)
+        return undefined;
+    return JSON.parse(text);
+}
+export async function requestBuffer(path, deps = {}) {
+    const apiKey = deps.apiKey ?? getApiKey();
+    const baseUrl = deps.baseUrl ?? getBaseUrl();
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const url = buildUrl(baseUrl, path);
+    const res = await fetchImpl(url, { method: "GET", headers: { "x-api-key": apiKey } });
+    if (!res.ok) {
+        const retryAfter = res.headers.get("retry-after") ?? undefined;
+        throw httpError(res.status, await errorMessage(res), retryAfter);
+    }
+    return Buffer.from(await res.arrayBuffer());
+}

package/dist/client.test.d.ts

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

package/dist/client.test.js

@@ -0,0 +1,127 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "./test-utils.js";
+import { getApiKey, getBaseUrl, request } from "./client.js";
+const ORIGINAL_KEY = process.env["AXIMO_API_KEY"];
+const ORIGINAL_URL = process.env["AXIMO_BASE_URL"];
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => {
+    server.close();
+    if (ORIGINAL_KEY !== undefined)
+        process.env["AXIMO_API_KEY"] = ORIGINAL_KEY;
+    else
+        delete process.env["AXIMO_API_KEY"];
+    if (ORIGINAL_URL !== undefined)
+        process.env["AXIMO_BASE_URL"] = ORIGINAL_URL;
+    else
+        delete process.env["AXIMO_BASE_URL"];
+});
+describe("getApiKey", () => {
+    it("returns AXIMO_API_KEY when set", () => {
+        expect(getApiKey()).toBe("test-key");
+    });
+    it("throws when unset", () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        try {
+            expect(() => getApiKey()).toThrow("AXIMO_API_KEY");
+        }
+        finally {
+            if (prev !== undefined)
+                process.env["AXIMO_API_KEY"] = prev;
+        }
+    });
+});
+describe("getBaseUrl", () => {
+    it("returns override without trailing slash", () => {
+        process.env["AXIMO_BASE_URL"] = "https://example.test/";
+        expect(getBaseUrl()).toBe("https://example.test");
+        process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    });
+    it("defaults to https://aximo.autify.com", () => {
+        delete process.env["AXIMO_BASE_URL"];
+        expect(getBaseUrl()).toBe("https://aximo.autify.com");
+        process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    });
+});
+describe("request", () => {
+    it("sends x-api-key header and parses JSON", async () => {
+        let seenKey = null;
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, ({ request: req }) => {
+            seenKey = req.headers.get("x-api-key");
+            return HttpResponse.json({ ok: "yes" });
+        }));
+        const result = await request("/api/health");
+        expect(result).toEqual({ ok: "yes" });
+        expect(seenKey).toBe("test-key");
+    });
+    it("encodes query string", async () => {
+        let seenUrl = "";
+        server.use(http.get(`${TEST_BASE_URL}/api/devices`, ({ request: req }) => {
+            seenUrl = req.url;
+            return HttpResponse.json({ devices: [] });
+        }));
+        await request("/api/devices", { query: { platform: "IOS", availableOnly: true } });
+        expect(seenUrl).toContain("platform=IOS");
+        expect(seenUrl).toContain("availableOnly=true");
+    });
+    it("POSTs JSON body with content-type", async () => {
+        let seenBody;
+        let seenCT = "";
+        server.use(http.post(`${TEST_BASE_URL}/api/sessions`, async ({ request: req }) => {
+            seenCT = req.headers.get("content-type") ?? "";
+            seenBody = await req.json();
+            return HttpResponse.json({ success: true, sessionId: "s1" }, { status: 201 });
+        }));
+        const result = await request("/api/sessions", {
+            method: "POST",
+            body: { title: "t" },
+        });
+        expect(result.sessionId).toBe("s1");
+        expect(seenCT).toContain("application/json");
+        expect(seenBody).toEqual({ title: "t" });
+    });
+    it("throws HttpError with status on non-2xx", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => HttpResponse.json({ error: "Unauthorized" }, { status: 401 })));
+        await expect(request("/api/boom")).rejects.toMatchObject({
+            status: 401,
+            message: "Unauthorized",
+        });
+    });
+    it("extracts error from {error} body", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/boom`, () => HttpResponse.json({ error: "Rate limit exceeded" }, { status: 429 })));
+        await expect(request("/api/boom")).rejects.toMatchObject({
+            status: 429,
+            message: "Rate limit exceeded",
+        });
+    });
+    it("attaches Retry-After header on 429", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/limited`, () => HttpResponse.json({ error: "slow down" }, { status: 429, headers: { "Retry-After": "60" } })));
+        await expect(request("/api/limited")).rejects.toMatchObject({
+            status: 429,
+            retryAfter: "60",
+        });
+    });
+    it("supports rawBody PUT (binary)", async () => {
+        let seenCT = "";
+        let seenMethod = "";
+        server.use(http.put(`${TEST_BASE_URL}/api/uploads/u1`, ({ request: req }) => {
+            seenCT = req.headers.get("content-type") ?? "";
+            seenMethod = req.method;
+            return HttpResponse.json({ success: true });
+        }));
+        const bytes = new Uint8Array([1, 2, 3]);
+        const result = await request("/api/uploads/u1", {
+            method: "PUT",
+            rawBody: bytes,
+            contentType: "application/octet-stream",
+        });
+        expect(result.success).toBe(true);
+        expect(seenCT).toContain("application/octet-stream");
+        expect(seenMethod).toBe("PUT");
+    });
+});