@autifyhq/aximo-cli 0.1.0 → 0.3.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,59 @@ 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 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 +132,32 @@ 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 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.
+
+### 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 +167,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
 
@@ -335,17 +356,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
+```
+
+**Other clients** — point them at the `aximo mcp` stdio command. Claude Desktop, Cursor, and Windsurf use the `mcpServers` key:
 
-# Production (default)
-aximo configure --base-url https://aximo.autify.com --api-key <prod-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 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.
 
 ## Agent Skills
 

package/dist/cli.js

@@ -1,6 +1,18 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import pkg from "../package.json" with { type: "json" };
+// citty's --help prints to stdout; route to stderr for `mcp` since its stdout
+// 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 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` +
+        `\n` +
+        `Stdout is reserved for JSON-RPC messages — diagnostics go to stderr.\n`);
+    process.exit(0);
+}
 const main = defineCommand({
     meta: {
         name: "aximo",
@@ -11,11 +23,14 @@ 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),
         project: () => import("./commands/project/index.js").then((m) => m.default),
         schema: () => import("./commands/schema.js").then((m) => m.default),
+        mcp: () => import("./commands/mcp/index.js").then((m) => m.default),
     },
 });
 runMain(main);

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

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

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

@@ -0,0 +1,86 @@
+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";
+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");
+    });
+});

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/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,7 @@
+import { defineCommand } from "citty";
+export default defineCommand({
+    meta: { name: "case", description: "Test case commands" },
+    subCommands: {
+        create: () => import("./create.js").then((m) => m.default),
+    },
+});

package/dist/commands/device/index.js

@@ -1,6 +1,9 @@
 import { defineCommand } from "citty";
 export default defineCommand({
-    meta: { name: "device", description: "Device commands" },
+    meta: {
+        name: "device",
+        description: "BYOD device commands (register/connect/status/...); 'device list' lists Device Farm mobile devices",
+    },
     subCommands: {
         list: () => import("./list.js").then((m) => m.default),
         register: () => import("./register.js").then((m) => m.default),

package/dist/commands/device/list.js

@@ -26,7 +26,10 @@ export async function runDeviceList(options = {}, deps) {
     }
 }
 export default defineCommand({
-    meta: { name: "list", description: "List Aximo devices" },
+    meta: {
+        name: "list",
+        description: "List Device Farm mobile devices (ANDROID/IOS) — not BYOD; for your registered machines use 'device status'",
+    },
     args: {
         platform: { type: "string", description: "ANDROID | IOS" },
         "available-only": { type: "boolean", description: "Only available devices" },

package/dist/commands/device/register.js

@@ -65,7 +65,7 @@ export async function runDeviceRegister(options, deps) {
     }
 }
 export default defineCommand({
-    meta: { name: "register", description: "Register this machine as an Aximo device" },
+    meta: { name: "register", description: "Register this machine as a BYOD device" },
     args: {
         name: {
             type: "string",

package/dist/commands/device/status.js

@@ -13,7 +13,10 @@ export async function runDeviceStatus(deps) {
     }
 }
 export default defineCommand({
-    meta: { name: "status", description: "List your registered devices" },
+    meta: {
+        name: "status",
+        description: "List your registered BYOD devices with online/offline status — not Device Farm (see 'device list')",
+    },
     async run() {
         printResult(await runDeviceStatus());
     },

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

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

package/dist/commands/mcp/index.js

@@ -0,0 +1,29 @@
+import { defineCommand } from "citty";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMcpServer } from "./server.js";
+import { getApiKey, getBaseUrl } from "../../client.js";
+// --help / -h are intercepted in cli.ts before citty parses argv.
+export default defineCommand({
+    meta: {
+        name: "mcp",
+        description: "Run an MCP server exposing Aximo data over stdio",
+    },
+    args: {},
+    async run() {
+        // Fail fast before the JSON-RPC handshake; diagnostics go to stderr only.
+        try {
+            getApiKey();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`aximo mcp: ${message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const baseUrl = getBaseUrl();
+        process.stderr.write(`aximo mcp: serving stdio MCP against ${baseUrl}\n`);
+        const server = createMcpServer();
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    },
+});

package/dist/commands/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ClientDeps } from "../../client.js";
+export declare function createMcpServer(deps?: ClientDeps): McpServer;

package/dist/commands/mcp/server.js

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { defineTools } from "./tools.js";
+import pkg from "../../../package.json" with { type: "json" };
+export function createMcpServer(deps = {}) {
+    const server = new McpServer({
+        name: "aximo",
+        version: pkg.version,
+    });
+    for (const tool of defineTools(deps)) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }, 
+        // biome-ignore lint/suspicious/noExplicitAny: SDK's registerTool signature is generic over schema; safe at runtime
+        tool.handler);
+    }
+    return server;
+}

package/dist/commands/mcp/server.test.d.ts

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