@autifyhq/aximo-cli 0.8.0 → 0.10.0

package/dist/commands/health/check.test.js

@@ -9,10 +9,34 @@ beforeAll(() => {
 afterEach(() => server.resetHandlers());
 afterAll(() => server.close());
 describe("runHealthCheck", () => {
-    it("returns ok envelope on 200", async () => {
-        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse(null, { status: 200 })));
+    it("returns ok envelope with auth when the API key is valid", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse(null, { status: 200 })), http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => HttpResponse.json({ projects: [] })));
         const result = await runHealthCheck();
-        expect(result).toEqual({ ok: true, data: { status: "ok" } });
+        expect(result).toEqual({ ok: true, data: { status: "ok", auth: "ok" } });
+    });
+    it("tolerates non-JSON bodies from both probes", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse("OK", { status: 200 })), http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => new HttpResponse("<html>projects</html>", { status: 200 })));
+        const result = await runHealthCheck();
+        expect(result).toEqual({ ok: true, data: { status: "ok", auth: "ok" } });
+    });
+    it("maps a rejected API key to unauthorized when the API is healthy", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse(null, { status: 200 })), http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => HttpResponse.json({ error: "Invalid API key" }, { status: 401 })));
+        const result = await runHealthCheck();
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("unauthorized");
+            expect(result.error.message).toContain("API is reachable but the API key was rejected");
+            expect(result.error.message).toContain("Invalid API key");
+        }
+    });
+    it("maps an auth-probe 500 to api_error without the rejected-key prefix", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/health`, () => new HttpResponse(null, { status: 200 })), http.get(`${TEST_BASE_URL}/api/organizations/projects`, () => HttpResponse.json({ error: "Internal" }, { status: 500 })));
+        const result = await runHealthCheck();
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.code).toBe("api_error");
+            expect(result.error.message).not.toContain("rejected");
+        }
     });
     it("maps 500 to api_error retryable", async () => {
         server.use(http.get(`${TEST_BASE_URL}/api/health`, () => HttpResponse.json({ error: "Internal" }, { status: 500 })));

package/dist/commands/mcp/server.test.js

@@ -24,7 +24,7 @@ async function connect() {
     };
 }
 describe("createMcpServer wiring", () => {
-    it("exposes all 16 tools through tools/list with valid JSON Schema", async () => {
+    it("exposes all 18 tools through tools/list with valid JSON Schema", async () => {
         const { client, cleanup } = await connect();
         try {
             const { tools } = await client.listTools();
@@ -44,6 +44,8 @@ describe("createMcpServer wiring", () => {
                 "aximo_create_plan",
                 "aximo_add_case_to_plan",
                 "aximo_remove_case_from_plan",
+                "aximo_list_plan_runs",
+                "aximo_get_plan_run",
                 "aximo_save_session_as_case",
             ].sort());
             const timeline = tools.find((t) => t.name === "aximo_get_session_timeline");

package/dist/commands/mcp/tools.js

@@ -260,6 +260,34 @@ export function defineTools(deps = {}) {
                 return await request(`/api/plans/${encodeURIComponent(planId)}/cases/${encodeURIComponent(caseId)}`, { method: "DELETE" }, deps);
             }),
         },
+        {
+            name: "aximo_list_plan_runs",
+            title: "List plan runs",
+            description: "List a plan's runs, newest first, without per-case detail. Use aximo_get_plan_run for one run's per-case breakdown. Paginate by passing the previous page's nextCursor as cursor. A run's status reflects execution, not the test verdict: read passedCases/failedCases to judge outcomes.",
+            inputSchema: {
+                planId: z.string().uuid(),
+                limit: z.number().int().positive().max(50).optional(),
+                cursor: z
+                    .string()
+                    .optional()
+                    .describe("nextCursor from the previous page (ISO 8601 createdAt of its last run)."),
+            },
+            handler: async ({ planId, ...rest }) => call(async () => {
+                return await request(`/api/triggers/plans/${encodeURIComponent(planId)}/runs`, { query: buildQuery(rest) }, deps);
+            }),
+        },
+        {
+            name: "aximo_get_plan_run",
+            title: "Get plan run status",
+            description: "Get the overall status and per-case breakdown of a plan run (from aximo_list_plan_runs, or the planRunId returned when a run was triggered). Poll this to observe a run in progress; wait at least 5 seconds between polls. A run's status reflects execution, not the test verdict: a run can complete with failedCases > 0, so read passedCases/failedCases and the per-case statuses to judge outcomes.",
+            inputSchema: {
+                planId: z.string().uuid(),
+                planRunId: z.string().uuid(),
+            },
+            handler: async ({ planId, planRunId }) => call(async () => {
+                return await request(`/api/triggers/plans/${encodeURIComponent(planId)}/runs/${encodeURIComponent(planRunId)}`, {}, deps);
+            }),
+        },
         {
             name: "aximo_save_session_as_case",
             title: "Save session as test case",

package/dist/commands/mcp/tools.test.js

@@ -36,6 +36,8 @@ describe("defineTools", () => {
             "aximo_create_plan",
             "aximo_add_case_to_plan",
             "aximo_remove_case_from_plan",
+            "aximo_list_plan_runs",
+            "aximo_get_plan_run",
             "aximo_save_session_as_case",
         ]);
     });
@@ -141,6 +143,94 @@ describe("aximo_list_projects", () => {
         expect(new URL(captured.url).pathname).toBe("/api/organizations/projects");
     });
 });
+describe("aximo_list_plan_runs", () => {
+    const planId = "77777777-7777-4777-9777-777777777777";
+    it("calls /api/triggers/plans/:id/runs, passing limit and cursor through", async () => {
+        let url = null;
+        const payload = {
+            items: [
+                {
+                    id: "88888888-8888-4888-9888-888888888888",
+                    status: "succeeded",
+                    triggerSource: "api",
+                    executionMode: "parallel",
+                    totalCases: 3,
+                    completedCases: 3,
+                    passedCases: 2,
+                    failedCases: 1,
+                    startedAt: "2026-07-01T00:00:00.000Z",
+                    completedAt: "2026-07-01T00:10:00.000Z",
+                    createdAt: "2026-07-01T00:00:00.000Z",
+                },
+            ],
+            nextCursor: "2026-07-01T00:00:00.000Z",
+        };
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/${planId}/runs`, ({ request: req }) => {
+            url = new URL(req.url);
+            return HttpResponse.json(payload);
+        }));
+        const tool = byName(defineTools(), "aximo_list_plan_runs");
+        const result = await tool.handler({
+            planId,
+            limit: 5,
+            cursor: "2026-07-02T00:00:00.000Z",
+        });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+        expect(url).not.toBeNull();
+        expect(url.searchParams.get("limit")).toBe("5");
+        expect(url.searchParams.get("cursor")).toBe("2026-07-02T00:00:00.000Z");
+    });
+    it("preserves the backend's 404 for an unknown plan", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/${planId}/runs`, () => HttpResponse.json({ error: "Test plan not found" }, { status: 404 })));
+        const tool = byName(defineTools(), "aximo_list_plan_runs");
+        const result = await tool.handler({ planId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("Test plan not found");
+    });
+});
+describe("aximo_get_plan_run", () => {
+    const planId = "77777777-7777-4777-9777-777777777777";
+    const planRunId = "99999999-9999-4999-9999-999999999999";
+    it("calls /api/triggers/plans/:id/runs/:runId and returns the run with cases", async () => {
+        const payload = {
+            id: planRunId,
+            status: "succeeded",
+            triggerSource: "api",
+            executionMode: "sequential",
+            totalCases: 1,
+            completedCases: 1,
+            passedCases: 0,
+            failedCases: 1,
+            startedAt: "2026-07-01T00:00:00.000Z",
+            completedAt: "2026-07-01T00:05:00.000Z",
+            createdAt: "2026-07-01T00:00:00.000Z",
+            cases: [
+                {
+                    id: "aaaaaaaa-aaaa-4aaa-9aaa-aaaaaaaaaaaa",
+                    caseId: "bbbbbbbb-bbbb-4bbb-9bbb-bbbbbbbbbbbb",
+                    title: "Login flow",
+                    type: "web",
+                    status: "failed",
+                    startedAt: "2026-07-01T00:00:10.000Z",
+                    completedAt: "2026-07-01T00:04:40.000Z",
+                },
+            ],
+        };
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/${planId}/runs/${planRunId}`, () => HttpResponse.json(payload)));
+        const tool = byName(defineTools(), "aximo_get_plan_run");
+        const result = await tool.handler({ planId, planRunId });
+        expect(result.isError).toBeUndefined();
+        expect(parsePayload(result)).toEqual(payload);
+    });
+    it("preserves the backend's 404 for an unknown run id", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/triggers/plans/${planId}/runs/${planRunId}`, () => HttpResponse.json({ error: "Plan run not found" }, { status: 404 })));
+        const tool = byName(defineTools(), "aximo_get_plan_run");
+        const result = await tool.handler({ planId, planRunId });
+        expect(result.isError).toBe(true);
+        expect(parsePayload(result).error).toBe("Plan run not found");
+    });
+});
 describe("call() error mapping", () => {
     const sessionId = "66666666-6666-4666-9666-666666666666";
     it("maps 403 with the original message and a hint", async () => {

package/dist/commands/mobile/connect-core.d.ts

@@ -1,5 +1,5 @@
 import type { ErrorEnvelope } from "../../types.js";
-import type { MobileController } from "../../mobile-control/controller.js";
+import { AppiumController } from "../../mobile-control/appium-controller.js";
 import { type IosSigningConfig } from "../../mobile-control/ios-signing.js";
 import { type MobileDeviceConfig } from "./paths.js";
 export declare function getTunnelOrigin(): string;
@@ -8,6 +8,8 @@ interface ConfigOk {
     config: MobileDeviceConfig;
 }
 export declare function resolveDeviceConfig(deviceId: string | undefined): ConfigOk | ErrorEnvelope;
-export declare function buildController(config: MobileDeviceConfig, endpoint: string, iosSigning?: IosSigningConfig, wdaLocalPort?: number | (() => Promise<number>)): MobileController;
-export declare function connectWithConfig(config: MobileDeviceConfig): Promise<void>;
+export declare function buildController(config: MobileDeviceConfig, endpoint: string, iosSigning?: IosSigningConfig, wdaLocalPort?: number | (() => Promise<number>), mjpegServerPort?: number | (() => Promise<number>)): AppiumController;
+export declare function connectWithConfig(config: MobileDeviceConfig, options?: {
+    assumeYes?: boolean;
+}): Promise<void>;
 export {};

package/dist/commands/mobile/connect-core.js

@@ -4,6 +4,8 @@ import { AppiumController } from "../../mobile-control/appium-controller.js";
 import { installUploadedApp } from "../../mobile-control/app-install.js";
 import { pickFreePort, startAppiumServer } from "../../mobile-control/appium-server.js";
 import { withBundleIdTranslation } from "../../mobile-control/bundle-id-map.js";
+import { FrameSender } from "../../mobile-control/frame-sender.js";
+import { MjpegStreamClient } from "../../mobile-control/mjpeg-stream.js";
 import { getIosDeviceInfo, iosMajorVersion } from "../../mobile-control/ios-devicectl.js";
 import { ensureIosTunnel, TUNNEL_STOP_COMMAND } from "../../mobile-control/ios-tunnel.js";
 import { resolveIosSigning, resolveIosSigningAuto, } from "../../mobile-control/ios-signing.js";
@@ -11,6 +13,7 @@ import { resolveWdaCaching } from "../../mobile-control/ios-wda-cache.js";
 import { resolvePreinstalledWdaStrategy } from "../../mobile-control/ios-wda-preinstall.js";
 import { runControlTunnel } from "../../mobile-control/tunnel.js";
 import { runMobileDoctor } from "./doctor.js";
+import { confirmIosSigning } from "./signing-consent.js";
 import { listMobileDeviceConfigs, readMobileDeviceConfig, } from "./paths.js";
 export function getTunnelOrigin() {
     return getBaseUrl().replace(/^http/, "ws");
@@ -37,11 +40,12 @@ export function resolveDeviceConfig(deviceId) {
     }
     return { ok: true, config: only };
 }
-export function buildController(config, endpoint, iosSigning, wdaLocalPort) {
+export function buildController(config, endpoint, iosSigning, wdaLocalPort, mjpegServerPort) {
     return new AppiumController({
         endpoint,
         platform: config.platform,
         target: config.target,
+        ...(mjpegServerPort ? { mjpegServerPort } : {}),
         ...(config.platform === "ios"
             ? { iosSigning: iosSigning ?? resolveIosSigning(), ...(wdaLocalPort ? { wdaLocalPort } : {}) }
             : {}),
@@ -86,12 +90,34 @@ async function preflightIosDevice(udid) {
     }
     return iosMajorVersion(info.osVersion);
 }
-export async function connectWithConfig(config) {
+export async function connectWithConfig(config, options) {
     await assertPrerequisites(config.platform);
     let iosMajor = null;
     let tunnelRunning = false;
+    let signing;
     if (config.platform === "ios") {
         iosMajor = await preflightIosDevice(config.target);
+        // Resolve and confirm the signing identity before any signing side effects —
+        // the RemoteXPC tunnel (admin prompt), Appium, WDA install, and profile
+        // minting against the user's Apple Developer account all come after, so
+        // declining costs nothing.
+        signing = await resolveIosSigningAuto({ udid: config.target });
+        if (signing.teamId) {
+            const accepted = await confirmIosSigning({
+                signing,
+                ...(options?.assumeYes !== undefined ? { assumeYes: options.assumeYes } : {}),
+            });
+            if (!accepted) {
+                console.error("Signing not accepted — not connecting. Re-run with --yes to skip this prompt, " +
+                    "or set AXIMO_IOS_TEAM_ID to sign with a different team.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        else {
+            console.error("No Apple signing identity found — physical-device WebDriverAgent signing will fail. " +
+                "Open Xcode → Settings → Accounts to add your Apple ID (see `aximo mobile doctor`).");
+        }
         // Physical iPhones on iOS 17+ need the RemoteXPC tunnel before XCUITest can
         // reach WebDriverAgent; start it (prompting for admin) unless one is running.
         // Older devices use the classic lockdown path — no tunnel, no admin prompt.
@@ -114,15 +140,7 @@ export async function connectWithConfig(config) {
     // installed profiles; env vars only override.
     let iosSigning;
     let wdaLocalPort;
-    if (config.platform === "ios") {
-        const signing = await resolveIosSigningAuto({ udid: config.target });
-        if (signing.teamId) {
-            console.error(`Signing as team ${signing.teamId} (WDA id ${signing.wdaBundleId}).`);
-        }
-        else {
-            console.error("No Apple signing identity found — physical-device WebDriverAgent signing will fail. " +
-                "Open Xcode → Settings → Accounts to add your Apple ID (see `aximo mobile doctor`).");
-        }
+    if (config.platform === "ios" && signing) {
         const preinstalled = await resolvePreinstalledWdaStrategy(signing, {
             udid: config.target,
             iosMajor,
@@ -145,10 +163,35 @@ export async function connectWithConfig(config) {
     }
     // Re-signing can remap bundle ids; launches from the backend use the original.
     const installedBundleIds = new Map();
-    const rawController = buildController(config, server.endpoint, iosSigning, wdaLocalPort);
+    const rawController = buildController(config, server.endpoint, iosSigning, wdaLocalPort, pickFreePort);
     const controller = config.platform === "ios"
         ? withBundleIdTranslation(rawController, installedBundleIds)
         : rawController;
+    // Live-view pipeline: capture (device MJPEG server -> local socket) feeds the
+    // sender (dedicated tunnel connection -> gateway). Started/stopped on demand
+    // by the gateway; frame acks reporting "no viewers" also stop it.
+    const frameSender = new FrameSender({
+        wsUrl: getTunnelOrigin(),
+        deviceToken: config.deviceToken,
+        onInactive: () => stream.stop(),
+        log: (message) => console.error(message),
+    });
+    const streamClient = new MjpegStreamClient({
+        ensureReady: () => rawController.ensureReady(),
+        getPort: () => rawController.getMjpegPort(),
+        onFrame: (frame) => frameSender.push(frame),
+        log: (message) => console.error(message),
+    });
+    const stream = {
+        start: () => {
+            frameSender.start();
+            streamClient.start();
+        },
+        stop: () => {
+            void streamClient.stop();
+            frameSender.stop();
+        },
+    };
     try {
         // Warm up the device session before connecting to Aximo so WDA build/signing/
         // trust problems surface here — with a clear, actionable message — instead of
@@ -163,6 +206,7 @@ export async function connectWithConfig(config) {
             deviceToken: config.deviceToken,
             deviceName: config.name,
             controller,
+            stream,
             installApp: async ({ uploadId }) => {
                 const result = await installUploadedApp({
                     uploadId,
@@ -181,6 +225,10 @@ export async function connectWithConfig(config) {
         });
     }
     finally {
+        // Await the capture loop before tearing down the controller/server so a
+        // mid-flight ensureReady/stream read can't race the Appium session close.
+        frameSender.stop();
+        await streamClient.stop();
         await controller.close();
         await server.stop();
         if (tunnelRunning) {

package/dist/commands/mobile/connect.d.ts

@@ -5,5 +5,10 @@ declare const _default: import("citty").CommandDef<{
         readonly type: "string";
         readonly description: "Registered device id (required if multiple)";
     };
+    readonly yes: {
+        readonly type: "boolean";
+        readonly alias: "y";
+        readonly description: "Skip the iOS code-signing confirmation prompt";
+    };
 }>;
 export default _default;

package/dist/commands/mobile/connect.js

@@ -17,6 +17,11 @@ export default defineCommand({
     },
     args: {
         "device-id": { type: "string", description: "Registered device id (required if multiple)" },
+        yes: {
+            type: "boolean",
+            alias: "y",
+            description: "Skip the iOS code-signing confirmation prompt",
+        },
     },
     async run({ args }) {
         const resolved = resolveDeviceConfig(args["device-id"]);
@@ -28,7 +33,7 @@ export default defineCommand({
         if (warning)
             console.error(warning);
         try {
-            await connectWithConfig(resolved.config);
+            await connectWithConfig(resolved.config, { assumeYes: Boolean(args.yes) });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/commands/mobile/signing-consent.d.ts

@@ -0,0 +1,18 @@
+import type { IosSigningConfig } from "../../mobile-control/ios-signing.js";
+export interface ConfirmIosSigningOptions {
+    signing: IosSigningConfig;
+    /** Skip the prompt entirely (--yes). The notice still prints. */
+    assumeYes?: boolean;
+    /** Whether a human can answer; defaults to stdin being a TTY. */
+    interactive?: boolean;
+    ask?: (question: string) => Promise<string>;
+    log?: (message: string) => void;
+}
+/**
+ * Informed consent before using the user's Apple signing identity: connecting
+ * can re-sign apps/WDA with it, register the device to the team's Apple
+ * Developer account, and create aximo App IDs in it. Defaults to yes (Enter
+ * proceeds); only an explicit n/no declines. Unattended connects (no TTY)
+ * proceed after printing the notice, so daemonized devices keep working.
+ */
+export declare function confirmIosSigning(options: ConfirmIosSigningOptions): Promise<boolean>;

package/dist/commands/mobile/signing-consent.js

@@ -0,0 +1,22 @@
+import { confirmYesNo } from "../../prompt.js";
+/**
+ * Informed consent before using the user's Apple signing identity: connecting
+ * can re-sign apps/WDA with it, register the device to the team's Apple
+ * Developer account, and create aximo App IDs in it. Defaults to yes (Enter
+ * proceeds); only an explicit n/no declines. Unattended connects (no TTY)
+ * proceed after printing the notice, so daemonized devices keep working.
+ */
+export async function confirmIosSigning(options) {
+    const { signing } = options;
+    const log = options.log ?? ((message) => console.error(message));
+    log(`Code signing: team ${signing.teamId} (WDA id ${signing.wdaBundleId}). Connecting may ` +
+        "re-sign apps and WebDriverAgent with this identity, register this device to the " +
+        "team's Apple Developer account, and create aximo App IDs in it. " +
+        "Set AXIMO_IOS_TEAM_ID to sign with a different team.");
+    if (options.assumeYes)
+        return true;
+    return confirmYesNo("Proceed with this signing identity?", {
+        ...(options.interactive === undefined ? {} : { interactive: options.interactive }),
+        ...(options.ask ? { ask: options.ask } : {}),
+    });
+}

package/dist/commands/mobile/signing-consent.test.d.ts

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

package/dist/commands/mobile/signing-consent.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from "vitest";
+import { confirmIosSigning } from "./signing-consent.js";
+const SIGNING = {
+    teamId: "TEAM123456",
+    signingId: "Apple Development",
+    wdaBundleId: "com.aximo.wda.TEAM123456",
+};
+describe("confirmIosSigning", () => {
+    it("prints a notice naming the team and its account-facing effects", async () => {
+        const log = vi.fn();
+        await confirmIosSigning({ signing: SIGNING, assumeYes: true, log });
+        const notice = log.mock.calls.map((c) => c[0]).join("\n");
+        expect(notice).toContain("TEAM123456");
+        expect(notice).toContain("Apple Developer account");
+        expect(notice).toContain("AXIMO_IOS_TEAM_ID");
+    });
+    it("skips the prompt with --yes", async () => {
+        const ask = vi.fn();
+        await expect(confirmIosSigning({
+            signing: SIGNING,
+            assumeYes: true,
+            interactive: true,
+            ask,
+            log: vi.fn(),
+        })).resolves.toBe(true);
+        expect(ask).not.toHaveBeenCalled();
+    });
+    it("proceeds without prompting when not interactive (daemonized connect)", async () => {
+        const ask = vi.fn();
+        await expect(confirmIosSigning({ signing: SIGNING, interactive: false, ask, log: vi.fn() })).resolves.toBe(true);
+        expect(ask).not.toHaveBeenCalled();
+    });
+    it("defaults to yes on Enter", async () => {
+        const ask = vi.fn(async () => "");
+        await expect(confirmIosSigning({ signing: SIGNING, interactive: true, ask, log: vi.fn() })).resolves.toBe(true);
+        expect(ask).toHaveBeenCalledWith("Proceed with this signing identity? [Y/n] ");
+    });
+    it("accepts y/yes and arbitrary input as yes", async () => {
+        for (const answer of ["y", "Y", "yes", " sure "]) {
+            const ask = vi.fn(async () => answer);
+            await expect(confirmIosSigning({ signing: SIGNING, interactive: true, ask, log: vi.fn() })).resolves.toBe(true);
+        }
+    });
+    it("declines only on an explicit n/no", async () => {
+        for (const answer of ["n", "N", "no", " NO "]) {
+            const ask = vi.fn(async () => answer);
+            await expect(confirmIosSigning({ signing: SIGNING, interactive: true, ask, log: vi.fn() })).resolves.toBe(false);
+        }
+    });
+});

package/dist/commands/plan/index.js

@@ -3,6 +3,7 @@ export default defineCommand({
     meta: { name: "plan", description: "Test plan commands" },
     subCommands: {
         create: () => import("./create.js").then((m) => m.default),
+        update: () => import("./update.js").then((m) => m.default),
         "add-case": () => import("./add-case.js").then((m) => m.default),
         "remove-case": () => import("./remove-case.js").then((m) => m.default),
     },

package/dist/commands/plan/plan.test.js

@@ -2,6 +2,7 @@ import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import { HttpResponse, http, server, TEST_BASE_URL } from "../../test-utils.js";
 import { runPlanAddCase } from "./add-case.js";
 import { runPlanCreate } from "./create.js";
+import { runPlanUpdate } from "./update.js";
 import { runPlanRemoveCase } from "./remove-case.js";
 beforeAll(() => {
     process.env["AXIMO_API_KEY"] = "test-key";
@@ -102,3 +103,63 @@ describe("runPlanRemoveCase", () => {
         }
     });
 });
+describe("runPlanUpdate", () => {
+    it("PATCHes the provided fields and returns the updated plan", async () => {
+        let seen;
+        server.use(http.patch(`${TEST_BASE_URL}/api/plans/pl1`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({
+                success: true,
+                plan: {
+                    id: "pl1",
+                    title: "Renamed",
+                    description: null,
+                    executionMode: "sequential",
+                    stopOnFailure: true,
+                    updatedAt: "2026-07-16T00:00:00Z",
+                },
+            });
+        }));
+        const result = await runPlanUpdate({
+            planId: "pl1",
+            title: "Renamed",
+            executionMode: "sequential",
+            stopOnFailure: "true",
+        });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data)) {
+            expect(result.data.plan.executionMode).toBe("sequential");
+        }
+        expect(seen).toMatchObject({
+            title: "Renamed",
+            executionMode: "sequential",
+            stopOnFailure: true,
+        });
+    });
+    it("rejects when no fields are provided", async () => {
+        const result = await runPlanUpdate({ planId: "pl1" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects an invalid executionMode", async () => {
+        const result = await runPlanUpdate({ planId: "pl1", executionMode: "fastest" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("rejects a non-boolean stop-on-failure", async () => {
+        const result = await runPlanUpdate({ planId: "pl1", stopOnFailure: "yes" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+    it("--dry-run returns the PATCH request without calling the API", async () => {
+        const result = await runPlanUpdate({ planId: "pl1", title: "t", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("PATCH");
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/plans/pl1`);
+        }
+    });
+});

package/dist/commands/plan/update.d.ts

@@ -0,0 +1,42 @@
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+import type { Envelope, UpdatePlanResult } from "../../types.js";
+export interface UpdatePlanOptions {
+    planId?: unknown;
+    title?: unknown;
+    description?: unknown;
+    executionMode?: unknown;
+    stopOnFailure?: unknown;
+    json?: unknown;
+    dryRun?: unknown;
+}
+export declare function runPlanUpdate(options: UpdatePlanOptions, deps?: ClientDeps): Promise<Envelope<UpdatePlanResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly planId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly title: {
+        readonly type: "string";
+    };
+    readonly description: {
+        readonly type: "string";
+    };
+    readonly "execution-mode": {
+        readonly type: "string";
+        readonly description: "parallel or sequential";
+    };
+    readonly "stop-on-failure": {
+        readonly type: "string";
+        readonly description: "true or false; sequential runs only";
+    };
+    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;