@autifyhq/aximo-cli 0.2.0 → 0.4.0

package/README.md

@@ -36,11 +36,7 @@ Get your API key from **Settings → API Keys** in the [Aximo dashboard](https:/
 
 ## 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`)
+Each credential resolves independently: the value in `$AXIMO_HOME/config.json` (written by `aximo configure`) wins, then the environment variable, then the default.
 
 | Variable         | Required | Default                    | Notes                                                        |
 | ---------------- | -------- | -------------------------- | ------------------------------------------------------------ |
@@ -48,60 +44,60 @@ The CLI resolves each credential independently in this order:
 | `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`
+Set them interactively or pass flags — config is written to `$AXIMO_HOME/config.json` (mode `0600` where the OS supports it; Windows falls back to file ACLs), and an empty prompt keeps the existing value:
 
 ```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:
+Or keep credentials out of a file (CI, ephemeral shells) with 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")
 ```
 
+Credentials and device registrations are **per-environment** — to switch between production and sandbox (`https://aximo-sbx.autify.dev`), re-run `aximo configure` with the other `--base-url`.
+
 ## 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                             |
+| 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 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.
 
@@ -137,6 +133,34 @@ aximo session get <sessionId>
 
 Desktop sessions default to `platform=desktop`, `model=sonnet`. Mobile sessions require both `--device-arn` and `--upload-arn`.
 
+### Test cases
+
+```bash
+aximo case create --project-id <id> --scenario <text> \
+  [--type web|mobile|desktop] [--title <t>] [--description <d>] \
+  [--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 delete` permanently removes a case: it is dropped from any plans it belongs to, and past run sessions are kept but detached.
+
+### Test plans
+
+```bash
+aximo plan create --project-id <id> --title <t> [--description <d>] [--json '<body>'] [--dry-run]
+aximo plan add-case    <planId> --case-id <caseId> [--json '<body>'] [--dry-run]
+aximo plan remove-case <planId> <caseId> [--dry-run]
+```
+
+Build a runnable plan: `plan create` → `plan add-case` (repeat per case) → `aximo trigger plan run`. Plans created this way have API access enabled by default. Cases must belong to the same workspace as the plan.
+
 ### Triggers (test cases and plans)
 
 ```bash
@@ -146,7 +170,7 @@ 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.
+Triggers a test case or plan. API access must be enabled on the resource — on by default for cases/plans created via this CLI; for dashboard-created ones, enable it in the Aximo dashboard settings. `trigger case run` returns a `sessionId` you can poll; `trigger plan run` returns a per-case breakdown.
 
 ### Uploads
 
@@ -226,6 +250,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
@@ -335,17 +386,33 @@ The agent disables DPI-awareness and uses a calibrated scroll amount — if you
 
 Default `$AXIMO_HOME` is `~/.aximo` on macOS/Linux, `%USERPROFILE%\.aximo` on Windows. Override via the `AXIMO_HOME` env var.
 
-### Sandbox vs production
+> Devices are registered per-environment (see [Configuration](#configuration)) — a device registered against sandbox can't connect to production and vice versa.
+
+## 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.
+
+It reuses the same credentials as every other command, so run `aximo configure` (or set `AXIMO_API_KEY`) first.
+
+**Claude Code** — one command:
 
 ```bash
-# Sandbox
-aximo configure --base-url https://aximo-sbx.autify.dev --api-key <sbx-key>
+claude mcp add aximo -- aximo mcp
+```
 
-# Production (default)
-aximo configure --base-url https://aximo.autify.com --api-key <prod-key>
+**Other clients** — point them at the `aximo mcp` stdio command. Claude Desktop, Cursor, and Windsurf use the `mcpServers` key:
+
+```json
+{
+  "mcpServers": {
+    "aximo": { "command": "aximo", "args": ["mcp"] }
+  }
+}
 ```
 
-Registrations are per-environment — a device registered against sandbox can't connect to production and vice versa.
+VS Code (Copilot agent mode) uses the same entry under a `servers` key in `.vscode/mcp.json`.
+
+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

@@ -5,7 +5,7 @@ import pkg from "../package.json" with { type: "json" };
 // is JSON-RPC.
 const args = process.argv.slice(2);
 if (args[0] === "mcp" && args.some((a) => a === "--help" || a === "-h")) {
-    process.stderr.write(`aximo mcp — stdio MCP server exposing read-only Aximo data.\n` +
+    process.stderr.write(`aximo mcp — stdio MCP server exposing Aximo data plus create operations.\n` +
         `\n` +
         `Wire into an MCP client (e.g. Claude Desktop, Claude Code) by pointing it\n` +
         `at this binary. Auth uses ~/.aximo/config.json (run \`aximo configure\`).\n` +
@@ -23,6 +23,8 @@ const main = defineCommand({
         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),
+        case: () => import("./commands/case/index.js").then((m) => m.default),
+        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),
         upload: () => import("./commands/upload/index.js").then((m) => m.default),

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

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

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

@@ -0,0 +1,120 @@
+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;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+const MIN = {
+    projectId: "proj-1",
+    scenario: "Open the login page and verify it loads",
+};
+describe("runCaseCreate", () => {
+    it("POSTs body and returns success envelope", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c1" }, { status: 201 });
+        }));
+        const result = await runCaseCreate({ ...MIN, type: "web", title: "Login" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.caseId).toBe("c1");
+        expect(seen).toMatchObject({
+            projectId: "proj-1",
+            scenario: "Open the login page and verify it loads",
+            type: "web",
+            title: "Login",
+        });
+    });
+    it("rejects missing projectId", async () => {
+        const result = await runCaseCreate({ scenario: "x" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects missing scenario", async () => {
+        const result = await runCaseCreate({ projectId: "p1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--json replaces individual flags and POSTs raw body", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ success: true, caseId: "c2" }, { status: 201 });
+        }));
+        const raw = JSON.stringify({ projectId: "p1", scenario: "raw", extra: true });
+        const result = await runCaseCreate({ json: raw });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ projectId: "p1", scenario: "raw", extra: true });
+    });
+    it("--dry-run returns request without calling API", async () => {
+        const result = await runCaseCreate({ ...MIN, dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.dryRun).toBe(true);
+            expect(result.data.method).toBe("POST");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/cases`);
+        }
+    });
+    it("returns unauthorized envelope when AXIMO_API_KEY unset", async () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        try {
+            const result = await runCaseCreate(MIN);
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error.code).toBe("unauthorized");
+        }
+        finally {
+            if (prev !== undefined)
+                process.env["AXIMO_API_KEY"] = prev;
+        }
+    });
+    it("maps 404 to not_found", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/cases`, () => HttpResponse.json({ error: "Project not found" }, { status: 404 })));
+        const result = await runCaseCreate(MIN);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            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/create.d.ts

@@ -0,0 +1,53 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { CreateCaseResult, Envelope } from "../../types.js";
+export interface CreateCaseOptions {
+    projectId?: unknown;
+    scenario?: unknown;
+    type?: unknown;
+    title?: unknown;
+    description?: unknown;
+    format?: unknown;
+    startUrl?: unknown;
+    directoryId?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runCaseCreate(options: CreateCaseOptions, deps?: ClientDeps): Promise<Envelope<CreateCaseResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly "project-id": {
+        readonly type: "string";
+    };
+    readonly scenario: {
+        readonly type: "string";
+    };
+    readonly type: {
+        readonly type: "string";
+        readonly description: "web | mobile | desktop";
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly description: {
+        readonly type: "string";
+    };
+    readonly format: {
+        readonly type: "string";
+        readonly description: "gherkin | markdown | plain_text";
+    };
+    readonly "start-url": {
+        readonly type: "string";
+    };
+    readonly "directory-id": {
+        readonly type: "string";
+    };
+    readonly json: {
+        readonly type: "string";
+        readonly description: "Raw JSON request body (replaces individual flags)";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/case/create.js

@@ -0,0 +1,71 @@
+import { defineCommand } from "citty";
+import { request } from "../../client.js";
+import { handleApiError } from "../../errors.js";
+import { dryRunEnvelope, resolveJsonOverride } from "../../mutate.js";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { optionalString, requireString } from "../../validate.js";
+export async function runCaseCreate(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 = {
+                projectId: requireString("projectId", options.projectId),
+                scenario: requireString("scenario", options.scenario),
+                type: optionalString("type", options.type),
+                title: optionalString("title", options.title),
+                description: optionalString("description", options.description),
+                format: optionalString("format", options.format),
+                startUrl: optionalString("startUrl", options.startUrl),
+                directoryId: optionalString("directoryId", options.directoryId),
+            };
+        }
+        catch (err) {
+            return validationError(err);
+        }
+    }
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", "/api/cases", body);
+    }
+    try {
+        const res = await request("/api/cases", { method: "POST", body }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "create", description: "Create a test case" },
+    args: {
+        "project-id": { type: "string" },
+        scenario: { type: "string" },
+        type: { type: "string", description: "web | mobile | desktop" },
+        title: { type: "string" },
+        description: { type: "string" },
+        format: { type: "string", description: "gherkin | markdown | plain_text" },
+        "start-url": { type: "string" },
+        "directory-id": { type: "string" },
+        json: { type: "string", description: "Raw JSON request body (replaces individual flags)" },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runCaseCreate({
+            projectId: args["project-id"],
+            scenario: args.scenario,
+            type: args.type,
+            title: args.title,
+            description: args.description,
+            format: args.format,
+            startUrl: args["start-url"],
+            directoryId: args["directory-id"],
+            json: args.json,
+            dryRun: args["dry-run"],
+        }));
+    },
+});

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.d.ts

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

package/dist/commands/case/index.js

@@ -0,0 +1,8 @@
+import { defineCommand } from "citty";
+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/doctor.d.ts

@@ -16,6 +16,7 @@ export interface DoctorReport {
         info: number;
     };
 }
+export declare function relayProbeUrl(): string;
 export interface RunDoctorOptions {
     skipRelay?: boolean;
     skipApi?: boolean;

package/dist/commands/device/doctor.js

@@ -1,13 +1,13 @@
-import { defineCommand } from "citty";
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { platform } from "node:os";
+import { defineCommand } from "citty";
 import { WebSocket } from "ws";
 import { getBaseUrl, request } from "../../client.js";
-import { formatSuccess, printResult } from "../../output.js";
 import { loadConfig } from "../../config.js";
 import { readCachedManifest } from "../../desktop-server/agent-sync.js";
 import { installedPythonTag, PYTHON_RELEASE, PYTHON_VERSION } from "../../desktop-server/setup.js";
+import { formatSuccess, printResult } from "../../output.js";
 import { getAgentRequirementsPath, getAgentScriptPath, getDepsMarkerPath, getDeviceConfigPath, getEmbeddedPythonBinary, getPythonDir, getPythonMarkerPath, } from "./paths.js";
 function redactKey(value) {
     if (value.length <= 8)
@@ -249,12 +249,21 @@ async function checkAgentUpToDate(deps) {
 function relayUrlFromBase() {
     return `${getBaseUrl().replace(/^http/, "ws")}/devices/tunnel`;
 }
+// The relay is a Socket.IO / engine.io endpoint (websocket-only), which answers
+// only at <path>/?EIO=4&transport=websocket. A raw WebSocket to the bare path
+// 404s or hangs, so the old probe reported a false negative even when the relay
+// was healthy. Probe the engine.io upgrade directly — a successful open (HTTP
+// 101) means the relay is up; device auth is enforced later, after this opens.
+export function relayProbeUrl() {
+    return `${relayUrlFromBase()}/?EIO=4&transport=websocket`;
+}
 const RELAY_CHECK_NAME = "relay handshake";
 function checkRelayReachable() {
     return new Promise((resolve) => {
         const url = relayUrlFromBase();
+        const probeUrl = relayProbeUrl();
         let settled = false;
-        const ws = new WebSocket(url, { handshakeTimeout: 5_000 });
+        const ws = new WebSocket(probeUrl, { handshakeTimeout: 5_000 });
         const done = (check) => {
             if (settled)
                 return;
@@ -280,7 +289,7 @@ function checkRelayReachable() {
             done({
                 name: RELAY_CHECK_NAME,
                 status: "pass",
-                message: `WebSocket handshake to ${url} succeeded (device auth not verified)`,
+                message: `engine.io upgrade to ${probeUrl} succeeded (device auth not verified)`,
             });
         });
         ws.on("error", (err) => {