@autifyhq/aximo-cli 0.3.0 → 0.5.0

package/README.md

@@ -64,39 +64,46 @@ Credentials and device registrations are **per-environment** — to switch betwe
 
 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 session save-as-case` | Save a finished session as a reusable test case      |
-| `aximo case create`          | Create a test case                                   |
-| `aximo plan create`          | Create a test plan                                   |
-| `aximo plan add-case`        | Add a case to a plan                                 |
-| `aximo plan remove-case`     | Remove a case from a plan                            |
-| `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                             |
-| `aximo mcp`                  | Run a stdio MCP server for agents (see below)        |
+| 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 session save-as-case` | Save a finished session as a reusable test case        |
+| `aximo case create`          | Create a test case                                     |
+| `aximo case delete`          | Delete a test case                                     |
+| `aximo plan create`          | Create a test plan                                     |
+| `aximo plan add-case`        | Add a case to a plan                                   |
+| `aximo plan remove-case`     | Remove a case from a plan                              |
+| `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 mobile list`          | List physically-connected phones (Android via adb)     |
+| `aximo mobile setup`         | Install the Appium drivers used to drive phones        |
+| `aximo mobile doctor`        | Diagnose Appium prerequisites (adb, SDK, driver)       |
+| `aximo mobile register`      | Register a connected Android phone as an Aximo device  |
+| `aximo mobile connect`       | Start managed Appium + open the tunnel for the phone   |
+| `aximo mobile unregister`    | Remove a local mobile device server-side + local creds |
+| `aximo schema`               | Show CLI surface as JSON                               |
+| `aximo mcp`                  | Run a stdio MCP server for agents (see below)          |
 
 Mutating commands support `--json '<raw body>'` for direct OpenAPI payloads and `--dry-run` to preview requests without executing.
 
@@ -140,13 +147,15 @@ aximo case create --project-id <id> --scenario <text> \
   [--format gherkin|markdown|plain_text] [--start-url <url>] \
   [--directory-id <id>] [--json '<body>'] [--dry-run]
 
+aximo case delete <caseId> [--dry-run]
+
 aximo session save-as-case <sessionId> \
   [--title <t>] [--type web|mobile|desktop] \
   [--scenario <text>] [--format gherkin|markdown|plain_text] \
   [--json '<body>'] [--dry-run]
 ```
 
-`case create` returns a `caseId` you can run with `aximo trigger case run`. `session save-as-case` persists a finished session (terminal status, not yet linked to a case) as a reusable case, carrying over its scenario and run config. Cases created either way have API access enabled by default, so they are triggerable immediately.
+`case create` returns a `caseId` you can run with `aximo trigger case run`. `session save-as-case` persists a finished session (terminal status, not yet linked to a case) as a reusable case, carrying over its scenario and run config. Cases created either way have API access enabled by default, so they are triggerable immediately. `case delete` permanently removes a case: it is dropped from any plans it belongs to, and past run sessions are kept but detached.
 
 ### Test plans
 
@@ -247,6 +256,33 @@ aximo device connect     # start the agent; keep the terminal open while tests r
 
 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.
 
+### Self-hosted servers (self-signed / custom CA)
+
+On-prem Aximo servers often present a self-signed certificate (a private "Aximo CA"). BYOD has **two** TLS clients: the Node CLI (API calls) and the embedded Python desktop agent (the `wss://…/devices/tunnel` relay). They trust a custom CA differently, so configure both:
+
+```bash
+# 1. Save the server's CA on this machine (or copy aximo-ca.pem from your admin).
+openssl s_client -connect YOUR_SERVER:8443 -showcerts </dev/null 2>/dev/null \
+  | awk '/BEGIN CERTIFICATE/{i++} i==2{print} /END CERTIFICATE/{if(i==2) exit}' > ~/aximo-ca.pem
+
+# 2. Point the CLI (Node) at it. Used for API calls AND auto-forwarded to the agent.
+export NODE_EXTRA_CA_CERTS="$HOME/aximo-ca.pem"
+
+aximo device connect
+```
+
+With `NODE_EXTRA_CA_CERTS` set, `device connect` automatically builds a combined trust store (the embedded Python's `certifi` roots **plus** your CA) and points the agent at it via `SSL_CERT_FILE`, so the relay connection verifies without extra steps.
+
+To override the agent's trust store explicitly, set `SSL_CERT_FILE` yourself. It must include public roots **and** your CA — `SSL_CERT_FILE` replaces the entire store, so your CA alone would break any other TLS the agent does (browser launch, uploads):
+
+```bash
+PYBIN="$HOME/.aximo/python/bin/python3"
+cat "$($PYBIN -m certifi)" ~/aximo-ca.pem > ~/.aximo/agent-ca-bundle.pem
+export SSL_CERT_FILE="$HOME/.aximo/agent-ca-bundle.pem"
+```
+
+Persist whichever variables you use in your shell profile. Public-CA servers (e.g. `aximo.autify.com`) need none of this.
+
 ### Managing devices
 
 ```bash
@@ -358,6 +394,64 @@ Default `$AXIMO_HOME` is `~/.aximo` on macOS/Linux, `%USERPROFILE%\.aximo` on Wi
 
 > Devices are registered per-environment (see [Configuration](#configuration)) — a device registered against sandbox can't connect to production and vice versa.
 
+## Mobile (local Android phone)
+
+The `mobile` commands let you register a **physically-connected Android phone** as an Aximo device and drive it locally, over the same gateway tunnel as desktop BYOD. Aximo's agent controls the phone through a CLI-managed [Appium](https://appium.io) (UiAutomator2) server — useful for running mobile tests against your own handset instead of a Device Farm device.
+
+> **Android only today.** iOS local devices are not yet supported — `aximo mobile register --platform ios` is blocked, and registration accepts only `--platform android`. (The Appium XCUITest plumbing is partially present but disabled; iOS local devices are planned for a future release.)
+
+Terminology note: **`aximo mobile list`** shows phones plugged into _this_ machine; **`aximo device list`** (under [Device / BYOD](#device-byod--bring-your-own-device)) returns mobile devices from AWS Device Farm. 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.
+- **A USB-connected Android phone** with **USB debugging** enabled in Developer Options, plugged in, and authorized (accept the "Allow USB debugging?" prompt on the phone).
+- **adb** (Android platform-tools) on your `PATH` — Appium delegates to it. Install via `brew install --cask android-platform-tools` (macOS), your distro's `adb` package (Linux), or the Android Studio SDK Manager (Windows).
+- **The Android SDK**, with `ANDROID_HOME` (or `ANDROID_SDK_ROOT`) set — e.g. installed via Android Studio. Appium's UiAutomator2 driver requires it even though adb is already on PATH.
+
+> The Appium server is bundled with the CLI, and the UiAutomator2 driver is installed by `aximo mobile setup` — you don't manage Appium yourself.
+
+### First-time setup
+
+```bash
+aximo mobile setup                          # installs the UiAutomator2 Appium driver
+aximo mobile doctor                         # checks adb / Android SDK / driver / bundled server
+```
+
+`setup` installs the Appium driver, then prints what (if anything) is still missing. `doctor` is the first thing to run when anything's off — it reports the bundled Appium server, the UiAutomator2 driver, `adb`, and the Android SDK in one shot, and exits non-zero if a required check fails.
+
+### Registering and connecting
+
+```bash
+aximo mobile list                                            # see connected phones + their adb serials
+aximo mobile register --name "My Pixel" --platform android   # --platform defaults to android
+aximo mobile connect                                         # starts managed Appium + opens the tunnel
+# Ctrl+C to disconnect
+```
+
+`register` writes credentials to `$AXIMO_HOME/mobile-devices/<deviceId>.json` (mode `0600`). It targets the single connected phone by default — pass `--serial` to pick a specific one when several are attached. `connect` re-checks prerequisites, starts the managed Appium server, and opens the tunnel; it runs until Ctrl+C. If you have more than one registered phone, pass `--device-id` to choose which to connect.
+
+Once connected, create a **mobile session in Aximo targeting this local device** — the agent routes its actions through the tunnel to the phone over Appium.
+
+### Managing devices
+
+```bash
+aximo mobile unregister                       # remove the locally registered device (server-side + local creds)
+aximo mobile unregister --device-id DEVICE_ID # target a specific device when several are registered
+```
+
+### Flags reference
+
+| Command                   | Flags                                                                               |
+| ------------------------- | ----------------------------------------------------------------------------------- |
+| `aximo mobile list`       | _(none)_                                                                            |
+| `aximo mobile setup`      | _(none)_                                                                            |
+| `aximo mobile doctor`     | _(none)_                                                                            |
+| `aximo mobile register`   | `--name <name>` (required), `--platform android` (default), `--serial <adb-serial>` |
+| `aximo mobile connect`    | `--device-id <id>` (required only if multiple devices are registered)               |
+| `aximo mobile unregister` | `--device-id <id>` (defaults to the locally registered device)                      |
+
 ## MCP server
 
 `aximo mcp` runs a [Model Context Protocol](https://modelcontextprotocol.io) server over stdio, exposing your recorded sessions, screenshots, and test cases to MCP-capable agents (Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, …). The motivating use: let an agent read a finished session and generate a Playwright spec without you piping JSON between commands.
@@ -382,7 +476,7 @@ claude mcp add aximo -- aximo mcp
 
 VS Code (Copilot agent mode) uses the same entry under a `servers` key in `.vscode/mcp.json`.
 
-The server exposes 15 tools: 10 read-only ones for inspecting sessions and cases (`aximo_get_session_timeline` is the load-bearing one for Playwright export) plus 5 that author content (create cases and plans, save a session as a case). See the [MCP reference](./skills/aximo-cli/references/mcp.md) for per-client config paths, the full tool table, the Playwright export prompt, and a no-client smoke test.
+The server exposes 16 tools: 10 read-only ones for inspecting sessions and cases (`aximo_get_session_timeline` is the load-bearing one for Playwright export) plus 6 that author content (create and delete cases, create plans, save a session as a case). See the [MCP reference](./skills/aximo-cli/references/mcp.md) for per-client config paths, the full tool table, the Playwright export prompt, and a no-client smoke test.
 
 ## Agent Skills
 

package/dist/cli.js

@@ -27,6 +27,7 @@ const main = defineCommand({
         plan: () => import("./commands/plan/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),
+        mobile: () => import("./commands/mobile/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),

package/dist/commands/case/case.test.js

@@ -1,6 +1,7 @@
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
 import { runCaseCreate } from "./create.js";
+import { runCaseDelete } from "./delete.js";
 beforeAll(() => {
     process.env["AXIMO_API_KEY"] = "test-key";
     process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
@@ -84,3 +85,36 @@ describe("runCaseCreate", () => {
             expect(result.error.code).toBe("not_found");
     });
 });
+describe("runCaseDelete", () => {
+    it("DELETEs the case path and returns success", async () => {
+        let called = false;
+        server.use(http.delete(`${TEST_BASE_URL}/api/cases/c1`, () => {
+            called = true;
+            return HttpResponse.json({ success: true });
+        }));
+        const result = await runCaseDelete({ caseId: "c1" });
+        expect(result.ok).toBe(true);
+        expect(called).toBe(true);
+    });
+    it("rejects missing caseId", async () => {
+        const result = await runCaseDelete({});
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("maps 404 to not_found", async () => {
+        server.use(http.delete(`${TEST_BASE_URL}/api/cases/c1`, () => HttpResponse.json({ error: "Test case not found" }, { status: 404 })));
+        const result = await runCaseDelete({ caseId: "c1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+    it("--dry-run returns a DELETE request without calling API", async () => {
+        const result = await runCaseDelete({ caseId: "c1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("DELETE");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases/c1`);
+        }
+    });
+});

package/dist/commands/case/delete.d.ts

@@ -0,0 +1,20 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { DeleteCaseResult, Envelope } from "../../types.js";
+export interface DeleteCaseOptions {
+    caseId?: unknown;
+    dryRun?: unknown;
+}
+export declare function runCaseDelete(options: DeleteCaseOptions, deps?: ClientDeps): Promise<Envelope<DeleteCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly caseId: {
+        readonly type: "positional";
+        readonly description: "Case ID";
+        readonly required: true;
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/case/delete.js

@@ -0,0 +1,39 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { dryRunEnvelope } from "../../mutate.js";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { requireId } from "../../validate.js";
+export async function runCaseDelete(options, deps) {
+    let caseId;
+    try {
+        caseId = requireId("caseId", options.caseId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    const path = `/api/cases/${encodeURIComponent(caseId)}`;
+    if (options.dryRun) {
+        return dryRunEnvelope("DELETE", path);
+    }
+    try {
+        const res = await request(path, { method: "DELETE" }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "delete", description: "Delete a test case" },
+    args: {
+        caseId: { type: "positional", description: "Case ID", required: true },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runCaseDelete({
+            caseId: args.caseId,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

package/dist/commands/case/index.js

@@ -3,5 +3,6 @@ export default defineCommand({
     meta: { name: "case", description: "Test case commands" },
     subCommands: {
         create: () => import("./create.js").then((m) => m.default),
+        delete: () => import("./delete.js").then((m) => m.default),
     },
 });

package/dist/commands/device/device-config.d.ts

@@ -0,0 +1,14 @@
+export interface DeviceConfig {
+    deviceId: string;
+    deviceToken: string;
+    name: string;
+    registeredAt: string;
+    baseUrl?: string;
+}
+/**
+ * Read and validate the local device registration (~/.aximo/device.json).
+ * Returns null when the file is missing, unreadable, or malformed.
+ */
+export declare function readDeviceConfig(): DeviceConfig | null;
+/** Persist the local device registration with owner-only permissions. */
+export declare function writeDeviceConfig(config: DeviceConfig): void;

package/dist/commands/device/device-config.js

@@ -0,0 +1,46 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { getAximoDir, getDeviceConfigPath } from "./paths.js";
+/**
+ * Read and validate the local device registration (~/.aximo/device.json).
+ * Returns null when the file is missing, unreadable, or malformed.
+ */
+export function readDeviceConfig() {
+    const path = getDeviceConfigPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const raw = parsed;
+        if (typeof raw.deviceId !== "string" ||
+            typeof raw.deviceToken !== "string" ||
+            typeof raw.name !== "string") {
+            return null;
+        }
+        return {
+            deviceId: raw.deviceId,
+            deviceToken: raw.deviceToken,
+            name: raw.name,
+            registeredAt: typeof raw.registeredAt === "string" ? raw.registeredAt : "",
+            ...(typeof raw.baseUrl === "string" ? { baseUrl: raw.baseUrl } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist the local device registration with owner-only permissions. */
+export function writeDeviceConfig(config) {
+    const dir = getAximoDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const path = getDeviceConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows; file-level ACLs apply instead.
+    }
+}

package/dist/commands/device/device-config.test.d.ts

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

package/dist/commands/device/device-config.test.js

@@ -0,0 +1,56 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { readDeviceConfig, writeDeviceConfig } from "./device-config.js";
+let tempHome;
+beforeEach(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-device-config-"));
+    process.env["AXIMO_HOME"] = tempHome;
+});
+afterEach(() => {
+    delete process.env["AXIMO_HOME"];
+    rmSync(tempHome, { recursive: true, force: true });
+});
+function devicePath() {
+    return join(tempHome, "device.json");
+}
+describe("device-config", () => {
+    it("returns null when the file is missing", () => {
+        expect(readDeviceConfig()).toBeNull();
+    });
+    it("round-trips a config including baseUrl", () => {
+        writeDeviceConfig({
+            deviceId: "d1",
+            deviceToken: "tok",
+            name: "mac",
+            registeredAt: "2026-06-29T00:00:00.000Z",
+            baseUrl: "https://srv:8443",
+        });
+        expect(readDeviceConfig()).toEqual({
+            deviceId: "d1",
+            deviceToken: "tok",
+            name: "mac",
+            registeredAt: "2026-06-29T00:00:00.000Z",
+            baseUrl: "https://srv:8443",
+        });
+    });
+    it("reads a pre-AT-577 file with no baseUrl (backward compatible)", () => {
+        writeFileSync(devicePath(), JSON.stringify({ deviceId: "d1", deviceToken: "tok", name: "mac", registeredAt: "t" }));
+        const cfg = readDeviceConfig();
+        expect(cfg).not.toBeNull();
+        expect(cfg?.deviceId).toBe("d1");
+        expect(cfg?.baseUrl).toBeUndefined();
+    });
+    it("returns null for malformed json or a missing deviceId", () => {
+        writeFileSync(devicePath(), "{ not json");
+        expect(readDeviceConfig()).toBeNull();
+        writeFileSync(devicePath(), JSON.stringify({ deviceToken: "tok", name: "mac" }));
+        expect(readDeviceConfig()).toBeNull();
+    });
+    it("writes the file with owner-only permissions", () => {
+        writeDeviceConfig({ deviceId: "d1", deviceToken: "tok", name: "mac", registeredAt: "t" });
+        // Sanity: file is valid JSON and readable back.
+        expect(JSON.parse(readFileSync(devicePath(), "utf-8"))).toMatchObject({ deviceId: "d1" });
+    });
+});

package/dist/commands/device/doctor.d.ts

@@ -16,6 +16,20 @@ export interface DoctorReport {
         info: number;
     };
 }
+export declare function relayProbeUrl(): string;
+export type TlsProbeResult = {
+    ok: true;
+} | {
+    ok: false;
+    kind: "cert" | "conn";
+    reason: string;
+};
+export interface AgentTlsDeps {
+    env?: NodeJS.ProcessEnv;
+    baseUrl?: string;
+    probe?: (host: string, port: number, ca: Buffer) => Promise<TlsProbeResult>;
+}
+export declare function checkAgentTlsTrust(deps?: AgentTlsDeps): Promise<Check>;
 export interface RunDoctorOptions {
     skipRelay?: boolean;
     skipApi?: boolean;