@bpmnkit/cli 0.0.16 → 0.0.18

package/README.md

@@ -109,6 +109,8 @@ casen instances list --state active
 | [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
 | [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
 | [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-http`](https://www.npmjs.com/package/@bpmnkit/casen-worker-http) | Example HTTP worker plugin — completes jobs with live JSONPlaceholder API data |
+| [`@bpmnkit/casen-worker-ai`](https://www.npmjs.com/package/@bpmnkit/casen-worker-ai) | AI task worker — classify, summarize, extract, and decide using Claude |
 
 ## License
 

package/dist/commands/index.js

@@ -4,10 +4,13 @@ import { askGroup } from "./ask.js";
 import { getDmnReqsXmlCmd, getDmnXmlCmd, getStartFormCmd, getUserTaskFormCmd, getXmlCmd, renderBpmnCmd, } from "./bpmn.js";
 import { completionGroup } from "./completion.js";
 import { connectorGroup } from "./connector.js";
+import { lintGroup } from "./lint.js";
 import { pluginGroup } from "./plugin.js";
 import { profileGroup } from "./profile.js";
 import { computeRelations } from "./relations.js";
 import { settingsGroup } from "./settings.js";
+import { storyGroup } from "./story.js";
+import { testGroup } from "./test.js";
 import { workerCmd } from "./worker.js";
 // Inject custom commands into generated groups without modifying generated files.
 // Also remove the broken generated get-x-m-l commands (return text/xml, not JSON)
@@ -30,23 +33,36 @@ const customisedGroups = generatedCommandGroups.map((g) => {
         return { ...g, commands: [...commands, getUserTaskFormCmd] };
     }
     if (g === jobGroup) {
-        return { ...g, commands: [...g.commands, workerCmd] };
+        return g;
     }
     return g;
 });
 const sortedOtherGroups = [
     connectorGroup,
-    pluginGroup,
     ...customisedGroups,
     ...adminCommandGroups,
     completionGroup,
 ].sort((a, b) => a.name.localeCompare(b.name));
-export const commandGroups = [
+const workerGroup = {
+    name: "worker",
+    description: workerCmd.description,
+    commands: [workerCmd],
+};
+/** Pinned groups shown above the separator in the main TUI menu. */
+export const pinnedGroups = [
     askGroup,
+    lintGroup,
+    storyGroup,
     settingsGroup,
-    profileGroup,
-    ...sortedOtherGroups,
+    testGroup,
+    workerGroup,
 ];
+/** API command groups — shown below the plugin section in the main TUI menu. */
+export const apiGroups = sortedOtherGroups;
+/** All built-in groups — used for CLI routing. */
+export const commandGroups = [...pinnedGroups, ...apiGroups];
+// Exported for CLI routing in run.ts (not shown in main TUI menu)
+export { pluginGroup, profileGroup };
 // Compute follow-up relations between commands based on shared field/arg names
 computeRelations(commandGroups);
 // Manually inject relations on GET commands (they return a single object, not a

package/dist/commands/lint.js

@@ -0,0 +1,219 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { Bpmn, compactify, optimize } from "@bpmnkit/core";
+const SEVERITY_SYMBOL = {
+    error: "✖",
+    warning: "⚠",
+    info: "ℹ",
+};
+const DEFAULT_SERVER = "http://localhost:3033";
+const lintCmd = {
+    name: "lint",
+    description: "Lint a BPMN file — run all static analysis and pattern checks",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "categories",
+            description: "Comma-separated categories to run (default: all)",
+            type: "string",
+        },
+        {
+            name: "format",
+            description: "Output format: text (default) or json",
+            type: "string",
+        },
+        {
+            name: "fix",
+            description: "Auto-apply all fixable findings and write the result back to the file",
+            type: "boolean",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const xml = await readFile(filePath, "utf-8");
+        const defs = Bpmn.parse(xml);
+        const categoriesFlag = ctx.flags.categories;
+        const categories = typeof categoriesFlag === "string" && categoriesFlag.length > 0
+            ? categoriesFlag.split(",").map((s) => s.trim())
+            : undefined;
+        const report = optimize(defs, categories !== undefined ? { categories } : undefined);
+        const { findings } = report;
+        // --fix: apply all auto-fixable findings and write back
+        if (ctx.flags.fix) {
+            const fixable = findings.filter((f) => f.applyFix);
+            for (const f of fixable)
+                f.applyFix?.(defs);
+            if (fixable.length === 0) {
+                ctx.output.ok("No auto-fixable issues found.");
+            }
+            else {
+                await writeFile(filePath, Bpmn.export(defs), "utf-8");
+                ctx.output.ok(`Fixed ${fixable.length} issue${fixable.length === 1 ? "" : "s"} and wrote ${filePath}`);
+            }
+            return;
+        }
+        const formatFlag = ctx.flags.format;
+        if (formatFlag === "json") {
+            ctx.output.print(findings);
+            return;
+        }
+        if (findings.length === 0) {
+            ctx.output.ok("No issues found.");
+            return;
+        }
+        for (const f of findings) {
+            const symbol = SEVERITY_SYMBOL[f.severity] ?? "·";
+            const elIds = f.elementIds.length > 0 ? ` [${f.elementIds.join(", ")}]` : "";
+            ctx.output.info(`${symbol} [${f.category}]${elIds} ${f.message}`);
+        }
+        const { total, bySeverity } = report.summary;
+        const errorCount = bySeverity.error ?? 0;
+        const warnCount = bySeverity.warning ?? 0;
+        const infoCount = bySeverity.info ?? 0;
+        ctx.output.info(`\n${total} finding${total !== 1 ? "s" : ""}: ${errorCount} error${errorCount !== 1 ? "s" : ""}, ${warnCount} warning${warnCount !== 1 ? "s" : ""}, ${infoCount} info`);
+        if (errorCount > 0) {
+            throw new Error(`Lint failed with ${errorCount} error${errorCount !== 1 ? "s" : ""}`);
+        }
+    },
+};
+function describeOp(op) {
+    switch (op.op) {
+        case "rename":
+            return `Rename to "${op.name}"`;
+        case "update":
+            return "Update element properties";
+        case "delete":
+            return "Remove element";
+        case "insert":
+            return `Add ${op.element.type}${op.element.name ? ` "${op.element.name}"` : ""}`;
+        case "add_flow":
+            return `Add flow: ${op.from} → ${op.to}`;
+        case "delete_flow":
+            return "Remove flow";
+        case "redirect_flow":
+            return "Redirect flow";
+    }
+}
+const improveCmd = {
+    name: "improve",
+    description: "AI-assisted BPMN improvement — analyzes and suggests fixes using an AI model",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "auto",
+            description: "Apply the AI-suggested improvements and write the result back to the file",
+            type: "boolean",
+        },
+        {
+            name: "server",
+            description: `AI proxy server URL (default: ${DEFAULT_SERVER})`,
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const serverUrl = typeof ctx.flags.server === "string" && ctx.flags.server.length > 0
+            ? ctx.flags.server
+            : DEFAULT_SERVER;
+        const xml = await readFile(filePath, "utf-8");
+        const defs = Bpmn.parse(xml);
+        const compactDiagram = compactify(defs);
+        let res;
+        try {
+            res = await fetch(`${serverUrl}/improve`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ context: compactDiagram, instruction: null, backend: null }),
+            });
+        }
+        catch (err) {
+            throw new Error(`Cannot reach AI server at ${serverUrl}. Start it with: pnpx @bpmnkit/ai-server\n${String(err)}`);
+        }
+        if (!res.ok || !res.body) {
+            throw new Error(`AI server returned ${res.status}`);
+        }
+        let capturedOps = [];
+        let capturedAutoFixCount = 0;
+        let capturedXml;
+        let hadOutput = false;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                const parts = buf.split("\n\n");
+                buf = parts.pop() ?? "";
+                for (const part of parts) {
+                    const line = part.startsWith("data: ") ? part.slice(6) : part;
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const event = JSON.parse(trimmed);
+                        if (event.type === "token" && event.text) {
+                            process.stdout.write(event.text);
+                            hadOutput = true;
+                        }
+                        if (event.type === "ops") {
+                            capturedOps = event.ops ?? [];
+                            capturedAutoFixCount = event.autoFixCount ?? 0;
+                        }
+                        if (event.type === "xml" && event.xml)
+                            capturedXml = event.xml;
+                        if (event.type === "error")
+                            throw new Error(event.message ?? "AI error");
+                    }
+                    catch (e) {
+                        if (e instanceof SyntaxError)
+                            continue;
+                        throw e;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (hadOutput)
+            process.stdout.write("\n\n");
+        // Print diff summary
+        if (capturedAutoFixCount > 0) {
+            ctx.output.info(`✓ ${capturedAutoFixCount} issue${capturedAutoFixCount === 1 ? "" : "s"} auto-fixed`);
+        }
+        if (capturedOps.length > 0) {
+            ctx.output.info("AI-suggested changes:");
+            for (const op of capturedOps) {
+                const prefix = op.op === "insert" || op.op === "add_flow"
+                    ? "+"
+                    : op.op === "delete" || op.op === "delete_flow"
+                        ? "−"
+                        : "~";
+                ctx.output.info(`  ${prefix} ${describeOp(op)}`);
+            }
+        }
+        if (capturedXml === undefined) {
+            ctx.output.info("No changes suggested.");
+            return;
+        }
+        if (ctx.flags.auto) {
+            await writeFile(filePath, capturedXml, "utf-8");
+            ctx.output.ok(`Improvements applied and written to ${filePath}`);
+        }
+        else {
+            ctx.output.info("\nRun with --auto to apply these changes.");
+        }
+    },
+};
+export const lintGroup = {
+    name: "lint",
+    description: "Lint BPMN files using the static analyzer",
+    commands: [lintCmd, improveCmd],
+};
+//# sourceMappingURL=lint.js.map

package/dist/commands/plugin.js

@@ -17,7 +17,7 @@ function runNpm(args, cwd) {
         child.on("error", reject);
     });
 }
-async function searchNpmRegistry(query) {
+export async function searchNpmRegistry(query) {
     const text = `keywords:casen-plugin${query ? ` ${query}` : ""}`;
     const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(text)}&size=50`;
     const res = await fetch(url);

package/dist/commands/profile.js

@@ -1,12 +1,27 @@
 import { readFileSync } from "node:fs";
-import { deleteProfile, getActiveName, getActiveProfile, getConfigFilePath, getProfile, listProfiles, saveProfile, useProfile, } from "@bpmnkit/profiles";
+import { deleteProfile, getActiveName, getActiveProfile, getConfigFilePath, getProfile, listProfiles, saveProfile, setProfileMeta, useProfile, } from "@bpmnkit/profiles";
 const API_TYPE_FLAG = {
     name: "api-type",
     description: "API type: c8 (default) or admin",
     type: "string",
     default: "c8",
     placeholder: "TYPE",
+    enum: ["c8", "admin"],
 };
+const META_FLAGS = [
+    {
+        name: "description",
+        description: "Short description of the profile",
+        type: "string",
+        placeholder: "TEXT",
+    },
+    {
+        name: "tags",
+        description: "Comma-separated tags (predefined: dev, stage, prod)",
+        type: "string",
+        placeholder: "TAGS",
+    },
+];
 const AUTH_FLAGS = [
     {
         name: "base-url",
@@ -21,6 +36,7 @@ const AUTH_FLAGS = [
         type: "string",
         required: true,
         placeholder: "TYPE",
+        enum: ["bearer", "oauth2", "basic", "none"],
     },
     {
         name: "token",
@@ -165,7 +181,7 @@ export const profileGroup = {
             name: "create",
             description: "Create or update a profile",
             args: [{ name: "name", description: "Profile name", required: true }],
-            flags: [API_TYPE_FLAG, ...AUTH_FLAGS],
+            flags: [API_TYPE_FLAG, ...AUTH_FLAGS, ...META_FLAGS],
             examples: [
                 {
                     description: "Bearer token profile",
@@ -191,7 +207,15 @@ export const profileGroup = {
                 const rawApiType = ctx.flags["api-type"] ?? "c8";
                 const apiType = rawApiType === "admin" ? "admin" : "c8";
                 const config = { baseUrl, auth };
-                saveProfile(name, config, apiType);
+                const description = ctx.flags.description;
+                const tagsRaw = ctx.flags.tags;
+                const tags = tagsRaw
+                    ? tagsRaw
+                        .split(",")
+                        .map((t) => t.trim())
+                        .filter(Boolean)
+                    : undefined;
+                saveProfile(name, config, apiType, { description, tags });
                 ctx.output.ok(`Profile "${name}" saved [${apiType}] (${getConfigFilePath()})`);
             },
         },
@@ -214,6 +238,7 @@ export const profileGroup = {
                         apiType: p.apiType,
                         baseUrl: p.config.baseUrl ?? "(from env/file)",
                         authType: p.config.auth?.type ?? "—",
+                        tags: p.tags && p.tags.length > 0 ? p.tags.join(", ") : "—",
                     })),
                 }, [
                     { key: "active", header: " " },
@@ -221,6 +246,7 @@ export const profileGroup = {
                     { key: "apiType", header: "API" },
                     { key: "baseUrl", header: "BASE URL", maxWidth: 50 },
                     { key: "authType", header: "AUTH TYPE" },
+                    { key: "tags", header: "TAGS" },
                 ]);
             },
         },
@@ -260,6 +286,10 @@ export const profileGroup = {
                 const active = getActiveName();
                 const isActive = profile.name === active;
                 ctx.output.info(`Profile: ${profile.name}${isActive ? " (active)" : ""}`);
+                if (profile.description)
+                    ctx.output.info(`Description: ${profile.description}`);
+                if (profile.tags && profile.tags.length > 0)
+                    ctx.output.info(`Tags: ${profile.tags.join(", ")}`);
                 ctx.output.printItem(profile.config);
             },
         },
@@ -304,6 +334,35 @@ export const profileGroup = {
                 ctx.output.info(`baseUrl: ${config.baseUrl ?? ""}`);
             },
         },
+        {
+            name: "meta",
+            description: "Update description or tags on an existing profile",
+            args: [{ name: "name", description: "Profile name", required: true }],
+            flags: META_FLAGS,
+            examples: [
+                {
+                    description: "Set description and tags",
+                    command: 'casen profile meta prod --description "Production cluster" --tags prod',
+                },
+            ],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                if (!name)
+                    throw new Error("Missing required argument: <name>");
+                const description = ctx.flags.description;
+                const tagsRaw = ctx.flags.tags;
+                const tags = tagsRaw
+                    ? tagsRaw
+                        .split(",")
+                        .map((t) => t.trim())
+                        .filter(Boolean)
+                    : undefined;
+                if (!setProfileMeta(name, { description, tags })) {
+                    throw new Error(`Profile "${name}" not found.`);
+                }
+                ctx.output.ok(`Profile "${name}" updated`);
+            },
+        },
         {
             name: "delete",
             aliases: ["rm"],

package/dist/commands/story.js

@@ -0,0 +1,42 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { Bpmn, renderStoryHtml } from "@bpmnkit/core";
+const storyCmd = {
+    name: "story",
+    description: "Render a BPMN process as a standalone story-mode HTML file",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "output",
+            short: "o",
+            description: "Output path (default: <file>.story.html)",
+            type: "string",
+        },
+        {
+            name: "theme",
+            description: "Color theme: light (default) or dark",
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const xml = await readFile(filePath, "utf-8");
+        const defs = Bpmn.parse(xml);
+        const themeFlag = ctx.flags.theme;
+        const theme = themeFlag === "dark" ? "dark" : "light";
+        const outputFlag = ctx.flags.output;
+        const outputPath = typeof outputFlag === "string" && outputFlag.length > 0
+            ? outputFlag
+            : `${filePath}.story.html`;
+        const html = renderStoryHtml(defs, { standalone: true, theme });
+        await writeFile(outputPath, html, "utf-8");
+        ctx.output.ok(`Story HTML written to ${outputPath}`);
+    },
+};
+export const storyGroup = {
+    name: "story",
+    description: "Render BPMN processes as narrative HTML",
+    commands: [storyCmd],
+};
+//# sourceMappingURL=story.js.map

package/dist/commands/test.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import { Bpmn } from "@bpmnkit/core";
+import { Engine, runScenario } from "@bpmnkit/engine";
+const testCmd = {
+    name: "test",
+    description: "Run scenario tests for a BPMN process file",
+    args: [
+        {
+            name: "file",
+            description: "Path to the .bpmn file",
+            required: true,
+        },
+    ],
+    flags: [
+        {
+            name: "scenarios",
+            short: "s",
+            description: "Path to the .bpmn.tests.json scenarios file (default: <file>.tests.json)",
+            type: "string",
+        },
+    ],
+    async run(ctx) {
+        const bpmnPath = ctx.positional[0];
+        if (bpmnPath === undefined)
+            throw new Error("Missing required argument: <file>");
+        const scenariosPath = typeof ctx.flags.scenarios === "string" ? ctx.flags.scenarios : `${bpmnPath}.tests.json`;
+        const bpmnXml = await readFile(bpmnPath, "utf8").catch(() => {
+            throw new Error(`Cannot read BPMN file: ${bpmnPath}`);
+        });
+        const scenariosRaw = await readFile(scenariosPath, "utf8").catch(() => {
+            throw new Error(`Cannot read scenarios file: ${scenariosPath}`);
+        });
+        let scenarios;
+        try {
+            scenarios = JSON.parse(scenariosRaw);
+        }
+        catch {
+            throw new Error(`Invalid JSON in scenarios file: ${scenariosPath}`);
+        }
+        if (!Array.isArray(scenarios) || scenarios.length === 0) {
+            ctx.output.info("No scenarios found.");
+            return;
+        }
+        const defs = Bpmn.parse(bpmnXml);
+        const engine = new Engine();
+        let passed = 0;
+        let failed = 0;
+        for (const scenario of scenarios) {
+            const result = await runScenario(engine, defs, scenario);
+            if (result.passed) {
+                passed++;
+                ctx.output.ok(`PASS  ${scenario.name}  (${result.durationMs}ms)`);
+            }
+            else {
+                failed++;
+                ctx.output.info(`FAIL  ${scenario.name}  (${result.durationMs}ms)`);
+                for (const f of result.failures) {
+                    ctx.output.info(`       ${f.field}: expected ${JSON.stringify(f.expected)}, got ${JSON.stringify(f.actual)}`);
+                }
+                for (const e of result.errors) {
+                    ctx.output.info(`       error${e.elementId !== undefined ? ` (${e.elementId})` : ""}: ${e.message}`);
+                }
+            }
+        }
+        const total = passed + failed;
+        ctx.output.info(`\n${passed}/${total} passed`);
+        if (failed > 0) {
+            throw new Error(`${failed} scenario(s) failed`);
+        }
+    },
+};
+export const testGroup = {
+    name: "test",
+    description: "Run scenario-based tests for BPMN processes",
+    commands: [testCmd],
+};
+//# sourceMappingURL=test.js.map

package/dist/commands/worker.js

@@ -11,11 +11,13 @@
 export const workerCmd = {
     name: "worker",
     description: "Run a simple job worker that auto-completes jobs of a given type",
+    _worker: { jobType: "io.camunda.connector.HttpJson:1" },
     args: [
         {
             name: "type",
             description: "Job type to subscribe to (matches the task definition type in BPMN)",
             required: true,
+            default: "io.camunda.connector.HttpJson:1",
         },
     ],
     flags: [
@@ -46,11 +48,11 @@ export const workerCmd = {
     examples: [
         {
             description: "Subscribe to jobs of type 'payment-service'",
-            command: "casen job worker payment-service",
+            command: "casen worker payment-service",
         },
         {
             description: "Return custom variables on completion",
-            command: 'casen job worker payment-service --variables \'{"status":"ok","amount":100}\'',
+            command: 'casen worker payment-service --variables \'{"status":"ok","amount":100}\'',
         },
     ],
     async run(ctx) {
@@ -92,7 +94,6 @@ export const workerCmd = {
                     worker: "casen-worker",
                     timeout,
                     maxJobsToActivate: maxJobs,
-                    requestTimeout: 20000, // 20 s long poll
                 }));
             }
             catch (err) {
@@ -107,24 +108,27 @@ export const workerCmd = {
             for (const job of jobs) {
                 if (!running)
                     break;
-                ctx.output.info(`Activated job ${job.jobKey}  process=${job.processDefinitionId}  element=${job.elementId}  instance=${job.processInstanceKey}`);
+                // Some Zeebe-compatible engines return `key` instead of `jobKey`
+                const jobKey = job.jobKey ?? job.key;
+                if (!jobKey) {
+                    ctx.output.info("Activated job has no key — skipping");
+                    continue;
+                }
+                ctx.output.info(`Activated job ${jobKey}  process=${job.processDefinitionId}  element=${job.elementId}  instance=${job.processInstanceKey}`);
                 if (Object.keys(job.variables ?? {}).length > 0) {
                     ctx.output.info(`  Input variables: ${JSON.stringify(job.variables)}`);
                 }
                 try {
-                    await client.job.completeJob(job.jobKey, { variables });
+                    await client.job.completeJob(jobKey, { variables });
                     completed++;
-                    ctx.output.ok(`Completed job ${job.jobKey} (total: ${completed})`);
+                    ctx.output.ok(`Completed job ${jobKey} (total: ${completed})`);
                 }
                 catch (err) {
-                    ctx.output.info(`Failed to complete job ${job.jobKey}: ${err instanceof Error ? err.message : String(err)}`);
+                    ctx.output.info(`Failed to complete job ${jobKey}: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
-            // When no jobs were returned, the long-poll already waited; loop immediately.
-            // When jobs were found, yield the event loop briefly before the next poll.
-            if (jobs.length > 0) {
-                await delay(100);
-            }
+            // Sleep between polls: brief yield after processing jobs, longer pause when idle
+            await delay(jobs.length > 0 ? 100 : 2000);
         }
         ctx.output.info(`\nWorker stopped. Completed ${completed} job(s).`);
     },

package/dist/generated/commands.js

@@ -53,6 +53,7 @@ export const authorizationGroup = {
         makeCreateCmd({
             description: "Create authorization",
             create: (client, body) => client.authorization.createAuthorization(body),
+            bodyFields: [{ name: "ownerId", type: "string", description: "The ID of the owner of the permissions.", required: true }, { name: "ownerType", type: "string", description: "The type of the owner of permissions.", required: true, enum: ["USER", "CLIENT", "ROLE", "GROUP", "MAPPING_RULE", "UNSPECIFIED"] }, { name: "resourceId", type: "string", description: "The ID of the resource to add permissions to.", required: true }, { name: "resourceType", type: "string", description: "The type of resource to add permissions to.", required: true }, { name: "permissionTypes", type: "array", description: "The permission types to add.", required: true }, { name: "resourcePropertyName", type: "string", description: "The name of the resource property on which this authorization is based.", required: true }],
         }),
         makeListCmd({
             description: "Search authorizations",
@@ -77,6 +78,7 @@ export const authorizationGroup = {
             description: "Update authorization",
             argName: "authorizationKey",
             update: (client, key, body) => client.authorization.updateAuthorization(key, body),
+            bodyFields: [{ name: "ownerId", type: "string", description: "The ID of the owner of the permissions.", required: true }, { name: "ownerType", type: "string", description: "The type of the owner of permissions.", required: true, enum: ["USER", "CLIENT", "ROLE", "GROUP", "MAPPING_RULE", "UNSPECIFIED"] }, { name: "resourceId", type: "string", description: "The ID of the resource to add permissions to.", required: true }, { name: "resourceType", type: "string", description: "The type of resource to add permissions to.", required: true }, { name: "permissionTypes", type: "array", description: "The permission types to add.", required: true }, { name: "resourcePropertyName", type: "string", description: "The name of the resource property on which this authorization is based.", required: true }],
         }),
         makeDeleteCmd({
             description: "Delete authorization",
@@ -354,6 +356,7 @@ export const decisionDefinitionGroup = {
             name: "evaluate",
             description: "Evaluate decision",
             create: (client, body) => client.decisionDefinition.evaluateDecision(body),
+            bodyFields: [{ name: "decisionDefinitionId", type: "string", description: " The ID of the decision to be evaluated.\n When using the decision ID, the latest\n deployed version of the decision is used.", required: true }, { name: "variables", type: "object", description: "The message variables as JSON document." }, { name: "tenantId", type: "string", description: "The tenant ID of the decision." }, { name: "decisionDefinitionKey", type: "string", description: "System-generated key for a decision definition.", required: true }],
         }),
         makeListCmd({
             description: "Search decision definitions",
@@ -1158,6 +1161,7 @@ export const processInstanceGroup = {
         makeCreateCmd({
             description: "Create process instance",
             create: (client, body) => client.processInstance.createProcessInstance(body),
+            bodyFields: [{ name: "processDefinitionKey", type: "string", description: " The unique key identifying the process definition, for example, returned for a process in the\n deploy resources endpoint.", required: true }, { name: "processDefinitionVersion", type: "string", description: " As the version is already identified by the `processDefinitionKey`, the value of this field is ignored.\n It's here for backwards-compatibility only as previous releases accepted it in request bodies." }, { name: "variables", type: "object", description: " Set of variables as JSON object to instantiate in the root variable scope of the process\n instance. Can include nested complex objects." }, { name: "startInstructions", type: "array", description: " List of start instructions. By default, the process instance will start at\n the start event. If provided, the process instance will apply start instructions\n after it has been created." }, { name: "runtimeInstructions", type: "array", description: " Runtime instructions (alpha). List of instructions that affect the runtime behavior of\n the process instance. Refer to specific instruction types for more details.\n\n This parameter is an alpha feature and may be subject to change\n in future releases." }, { name: "tenantId", type: "string", description: " The tenant id of the process definition.\n If multi-tenancy is enabled, provide the tenant id of the process definition to start a\n process instance of. If multi-tenancy is disabled, don't provide this parameter." }, { name: "operationReference", type: "string", description: " A reference key chosen by the user that will be part of all records resulting from this operation.\n Must be > 0 if provided." }, { name: "awaitCompletion", type: "boolean", description: " Wait for the process instance to complete. If the process instance does not complete\n within the request timeout limit, a 504 response status will be returned. The process\n instance will continue to run in the background regardless of the timeout. Disabled by\n default." }, { name: "requestTimeout", type: "string", description: " Timeout (in ms) the request waits for the process to complete. By default or\n when set to 0, the generic request timeout configured in the cluster is applied." }, { name: "fetchVariables", type: "array", description: " List of variables by name to be included in the response when awaitCompletion is set to true.\n If empty, all visible variables in the root scope will be returned." }, { name: "tags", type: "array", description: "List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100." }, { name: "businessId", type: "string", description: " An optional, user-defined string identifier that identifies the process instance\n within the scope of a process definition (scoped by tenant). If provided and uniqueness\n enforcement is enabled, the engine will reject creation if another root process instance\n with the same business id is already active for the same process definition.\n Note that any active child process instances with the same business id are not taken into account." }, { name: "processDefinitionId", type: "string", description: " The BPMN process id of the process definition to start an instance of.", required: true }],
         }),
         makeCreateCmd({
             name: "cancel-batch-operation",