@bpmnkit/cli 0.0.17 → 0.0.18

package/dist/commands/lint.js

@@ -1,10 +1,11 @@
-import { readFile } from "node:fs/promises";
-import { Bpmn, optimize } from "@bpmnkit/core";
+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",
@@ -20,6 +21,11 @@ const lintCmd = {
             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];
@@ -33,6 +39,20 @@ const lintCmd = {
             : 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);
@@ -57,9 +77,143 @@ const lintCmd = {
         }
     },
 };
+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],
+    commands: [lintCmd, improveCmd],
 };
 //# sourceMappingURL=lint.js.map

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/worker.js

@@ -94,7 +94,6 @@ export const workerCmd = {
                     worker: "casen-worker",
                     timeout,
                     maxJobsToActivate: maxJobs,
-                    requestTimeout: 20000, // 20 s long poll
                 }));
             }
             catch (err) {
@@ -109,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",

package/dist/output.js

@@ -259,4 +259,29 @@ export function printRawResponse(raw, noColor) {
         process.stdout.write(`${raw.body}\n`);
     }
 }
+/** Print HTTP error details (request + response) to stderr. */
+export function printHttpErrorDetails(raw, noColor) {
+    const colors = shouldUseColor(noColor);
+    process.stderr.write(`\n${dim("→", colors)} ${bold(`${raw.method} ${raw.url}`, colors)}\n`);
+    for (const [k, v] of Object.entries(raw.requestHeaders)) {
+        process.stderr.write(`  ${dim(k, colors)}: ${v}\n`);
+    }
+    if (raw.requestBody) {
+        process.stderr.write(`\n${dim(raw.requestBody, colors)}\n`);
+    }
+    process.stderr.write(`\n${red(`HTTP ${raw.status}`, colors)}\n`);
+    for (const [k, v] of Object.entries(raw.headers)) {
+        process.stderr.write(`  ${dim(k, colors)}: ${v}\n`);
+    }
+    if (raw.body) {
+        process.stderr.write("\n");
+        try {
+            const parsed = JSON.parse(raw.body);
+            process.stderr.write(`${JSON.stringify(parsed, null, 2)}\n`);
+        }
+        catch {
+            process.stderr.write(`${raw.body}\n`);
+        }
+    }
+}
 //# sourceMappingURL=output.js.map

package/dist/run.js

@@ -3,7 +3,7 @@ import { parseArgs } from "./args.js";
 import { apiGroups, commandGroups, pinnedGroups, pluginGroup, profileGroup, } from "./commands/index.js";
 import { getRuntimeCompletions } from "./completion.js";
 import { printCommandHelp, printGlobalHelp, printGroupHelp, printVersion } from "./help.js";
-import { createNullWriter, createOutputWriter, printRawResponse } from "./output.js";
+import { createNullWriter, createOutputWriter, printHttpErrorDetails, printRawResponse, } from "./output.js";
 import { loadPlugins } from "./plugin-loader.js";
 import { runProfileManager } from "./profile-tui.js";
 import { runSettingsManager } from "./settings-tui.js";
@@ -240,6 +240,9 @@ export async function run(argv) {
         if (isRaw && capture) {
             printRawResponse(capture, noColor);
         }
+        else if (capture) {
+            printHttpErrorDetails(capture, noColor);
+        }
         const msg = err instanceof Error ? err.message : String(err);
         appendAuditEntry(effectiveProfile, {
             group: group.name,

package/dist/tui.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { renderBpmnAscii } from "@bpmnkit/ascii";
-import { appendAuditEntry, getAuditLog, getSettings, saveSettings } from "@bpmnkit/profiles";
+import { appendAuditEntry, deleteProfile, getActiveName, getAuditLog, getProfile, getSettings, listProfiles, saveSettings, useProfile, } from "@bpmnkit/profiles";
 import { runAskQuery } from "./commands/ask.js";
 import { pluginGroup, searchNpmRegistry } from "./commands/plugin.js";
 import { profileGroup } from "./commands/profile.js";
@@ -193,8 +193,9 @@ function entriesToJson(entries) {
 }
 /**
  * Build initial entries for the JSON editor.
- * If fieldSpecs are provided, pre-populate with all known fields (in spec order),
- * merging in any existing values. Extra keys from existing JSON are appended at the end.
+ * If fieldSpecs are provided, pre-populate only required fields (in spec order),
+ * merging in any existing values. Optional fields are available via the add-row picker.
+ * Extra keys from existing JSON that are not in the spec are appended at the end.
  */
 function buildInitialEntries(existingJson, fieldSpecs) {
     const existing = {};
@@ -213,7 +214,10 @@ function buildInitialEntries(existingJson, fieldSpecs) {
         return parseJsonToEntries(existingJson);
     const seenKeys = new Set();
     const entries = [];
+    // Only pre-populate required fields; optional ones are added on demand
     for (const spec of fieldSpecs) {
+        if (!spec.required && !(spec.name in existing))
+            continue;
         seenKeys.add(spec.name);
         const val = existing[spec.name] ?? "";
         entries.push({ key: spec.name, keyCursor: spec.name.length, val, valCursor: val.length });
@@ -230,6 +234,57 @@ function buildInitialEntries(existingJson, fieldSpecs) {
 function getFieldSpec(key, fieldSpecs) {
     return fieldSpecs?.find((s) => s.name === key);
 }
+/**
+ * Return specs not already used as keys by OTHER entries (not the one at currentIndex).
+ * Pass null for currentIndex when adding a brand-new entry.
+ */
+function getAvailableFieldSpecs(currentIndex, entries, fieldSpecs) {
+    const usedKeys = new Set(entries
+        .filter((_, i) => i !== currentIndex)
+        .map((e) => e.key)
+        .filter(Boolean));
+    return fieldSpecs.filter((s) => !usedKeys.has(s.name));
+}
+/** Build profile info entries (key/value pairs with secrets redacted). */
+function buildProfileInfoEntries(profileName) {
+    const p = getProfile(profileName);
+    if (!p)
+        return [{ key: "status", value: "profile not found" }];
+    const info = [
+        { key: "name", value: p.name },
+        { key: "apiType", value: p.apiType },
+        { key: "baseUrl", value: p.config.baseUrl ?? "(default)" },
+    ];
+    const auth = p.config.auth;
+    if (auth) {
+        info.push({ key: "auth.type", value: auth.type });
+        if (auth.type === "bearer") {
+            info.push({ key: "auth.token", value: "***" });
+        }
+        else if (auth.type === "oauth2") {
+            info.push({ key: "auth.clientId", value: auth.clientId });
+            info.push({ key: "auth.clientSecret", value: "***" });
+            info.push({ key: "auth.tokenUrl", value: auth.tokenUrl });
+        }
+        else if (auth.type === "basic") {
+            info.push({ key: "auth.username", value: auth.username });
+            info.push({ key: "auth.password", value: "***" });
+        }
+    }
+    return info;
+}
+/** Rebuild profile list items after use/delete. */
+function rebuildProfileListItems() {
+    const profiles = listProfiles();
+    const active = getActiveName();
+    return profiles.map((p) => ({
+        active: p.name === active ? "●" : " ",
+        name: p.name,
+        apiType: p.apiType,
+        baseUrl: p.config.baseUrl ?? "(from env/file)",
+        authType: p.config.auth?.type ?? "—",
+    }));
+}
 // ─── Table helpers ────────────────────────────────────────────────────────────
 function getCellStr(item, col) {
     let val = item;
@@ -515,6 +570,22 @@ function renderInput(state, screen) {
     lines.push("");
     if (screen.error) {
         lines.push(`  ${red("error:")} ${screen.error}`);
+        if (screen.errorRaw) {
+            const raw = screen.errorRaw;
+            lines.push(`  ${dim(`${raw.method} ${raw.url}`)}`);
+            lines.push(`  ${red(`HTTP ${raw.status}`)}`);
+            if (raw.body) {
+                try {
+                    const parsed = JSON.parse(raw.body);
+                    for (const l of JSON.stringify(parsed, null, 2).split("\n")) {
+                        lines.push(`  ${dim(l)}`);
+                    }
+                }
+                catch {
+                    lines.push(`  ${dim(raw.body)}`);
+                }
+            }
+        }
     }
     else if (screen.running) {
         lines.push(`  ${dim("running…")}`);
@@ -707,7 +778,12 @@ function renderResults(state, screen) {
             lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${out.total}`)}`);
         }
         const followupHint = screen.cmd.relations ? `  ${cyan("f")} follow-up` : "";
-        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} detail${followupHint}  ${dim("pgup/pgdn")} page${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+        const profileListHints = screen.group.name === "profile" && screen.cmd.name === "list"
+            ? `  ${cyan("u")} use  ${cyan("s")} show  ${cyan("d")} delete`
+            : "";
+        if (screen.message)
+            lines.push(`  ${green(screen.message)}`);
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} detail${followupHint}${profileListHints}  ${dim("pgup/pgdn")} page${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
     }
     else if (out.type === "item") {
         lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
@@ -1032,12 +1108,15 @@ function renderJsonEditor(state, screen) {
         const editKey = isCursor && screen.col === "key" && screen.editing;
         const editVal = isCursor && screen.col === "val" && screen.editing;
         const keyStr = renderText(entry.key, entry.keyCursor, keyW - (isKnown ? 0 : 0), editKey);
-        // For known enum fields in nav mode, show cycling hint instead of raw value
+        // For known enum fields in nav mode, show cycling hint instead of raw value.
+        // For non-enum known fields, show a type placeholder when value is empty.
         const valDisplay = !editVal && hasEnum && entry.val
             ? `${entry.val} ${dim("↑↓")}`
             : !editVal && hasEnum && !entry.val
                 ? dim("<pick ↑↓>")
-                : renderText(entry.val, entry.valCursor, valW - 4, editVal);
+                : !editVal && !hasEnum && spec && !entry.val
+                    ? dim(`<${spec.type}>`)
+                    : renderText(entry.val, entry.valCursor, valW - 4, editVal);
         const valStr = valDisplay;
         const keyPart = isCursor && screen.col === "key" && !editKey
             ? cyan(padEnd(keyStr, keyW))
@@ -1079,7 +1158,9 @@ function renderJsonEditor(state, screen) {
             : undefined;
         const editHint = editSpec?.enum
             ? `${dim("↑↓")} pick value  ${cyan("enter")} confirm  ${cyan("esc")} cancel`
-            : `${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`;
+            : screen.col === "key" && screen.fieldSpecs && screen.fieldSpecs.length > 0
+                ? `${dim("↑↓")} pick field  ${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`
+                : `${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`;
         lines.push(`  ${editHint}`);
     }
     else {
@@ -1140,7 +1221,6 @@ async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
                 worker: "casen-worker",
                 timeout: jobTimeout,
                 maxJobsToActivate: maxJobs,
-                requestTimeout: 20000,
             }));
         }
         catch (err) {
@@ -1154,13 +1234,19 @@ async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
         for (const job of jobs) {
             if (!running)
                 break;
+            // Some Zeebe-compatible engines return `key` instead of `jobKey`
+            const jobKey = job.jobKey ?? job.key;
+            if (!jobKey) {
+                addWorkerLog(ws, "err", "Activated job has no key — skipping");
+                continue;
+            }
             ws.stats.activated++;
-            addWorkerLog(ws, "info", `Activated ${job.jobKey}  process=${job.processDefinitionId}  element=${job.elementId}`);
+            addWorkerLog(ws, "info", `Activated ${jobKey}  process=${job.processDefinitionId}  element=${job.elementId}`);
             let jobResult = { outcome: "complete", variables };
             const processJob = ws.cmd._worker?.processJob;
             if (processJob) {
                 try {
-                    jobResult = await processJob(job);
+                    jobResult = await processJob({ ...job, jobKey });
                 }
                 catch (err) {
                     addWorkerLog(ws, "err", `Handler error: ${err instanceof Error ? err.message : String(err)} — using defaults`);
@@ -1168,36 +1254,36 @@ async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
             }
             try {
                 if (jobResult.outcome === "complete") {
-                    await client.job.completeJob(job.jobKey, { variables: jobResult.variables });
+                    await client.job.completeJob(jobKey, { variables: jobResult.variables });
                     ws.stats.completed++;
-                    addWorkerLog(ws, "ok", `Completed ${job.jobKey}`);
+                    addWorkerLog(ws, "ok", `Completed ${jobKey}`);
                 }
                 else if (jobResult.outcome === "fail") {
-                    await client.job.failJob(job.jobKey, {
+                    await client.job.failJob(jobKey, {
                         errorMessage: jobResult.errorMessage,
                         retries: jobResult.retries,
                         retryBackOff: jobResult.retryBackOff,
                     });
                     ws.stats.failed++;
-                    addWorkerLog(ws, "err", `Failed ${job.jobKey}: ${jobResult.errorMessage}`);
+                    addWorkerLog(ws, "err", `Failed ${jobKey}: ${jobResult.errorMessage}`);
                 }
                 else {
-                    await client.job.throwJobError(job.jobKey, {
+                    await client.job.throwJobError(jobKey, {
                         errorCode: jobResult.errorCode,
                         errorMessage: jobResult.errorMessage,
                         variables: jobResult.variables,
                     });
                     ws.stats.failed++;
-                    addWorkerLog(ws, "err", `Error ${job.jobKey} [${jobResult.errorCode}]: ${jobResult.errorMessage ?? ""}`);
+                    addWorkerLog(ws, "err", `Error ${jobKey} [${jobResult.errorCode}]: ${jobResult.errorMessage ?? ""}`);
                 }
             }
             catch (err) {
                 ws.stats.failed++;
-                addWorkerLog(ws, "err", `Failed to settle ${job.jobKey}: ${err instanceof Error ? err.message : String(err)}`);
+                addWorkerLog(ws, "err", `Failed to settle ${jobKey}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        if (jobs.length > 0)
-            await new Promise((r) => setTimeout(r, 100));
+        // Sleep between polls: brief yield after processing jobs, longer pause when idle
+        await new Promise((r) => setTimeout(r, jobs.length > 0 ? 100 : 2000));
     }
     ws.status = "stopped";
     addWorkerLog(ws, "info", `Stopped. Activated: ${ws.stats.activated}  Completed: ${ws.stats.completed}  Failed: ${ws.stats.failed}`);
@@ -1321,6 +1407,7 @@ async function runAskInTui(screen, state) {
         },
         raw: null,
         rawView: false,
+        message: "",
         curlView: false,
         altView: false,
         cursor: 0,
@@ -1559,6 +1646,7 @@ function handleMainKey(key, screen, state, done) {
                     scroll: 0,
                     editing: false,
                     error: "",
+                    errorRaw: null,
                     running: false,
                 });
             }
@@ -1626,6 +1714,7 @@ function handleCommandsKey(key, screen, state, done) {
                     scroll: 0,
                     editing: false,
                     error: "",
+                    errorRaw: null,
                     running: false,
                 });
             }
@@ -1655,6 +1744,7 @@ async function executeCommand(screen, state) {
     }
     screen.running = true;
     screen.error = "";
+    screen.errorRaw = null;
     render(state);
     const { writer, get } = makeCapturingWriter();
     // Wrap client factories to capture the last raw HTTP response
@@ -1713,6 +1803,7 @@ async function executeCommand(screen, state) {
             altView: false,
             cursor: 0,
             scroll: 0,
+            message: "",
         });
     }
     catch (err) {
@@ -1726,6 +1817,7 @@ async function executeCommand(screen, state) {
             error: msg,
         });
         screen.error = msg;
+        screen.errorRaw = rawCapture;
     }
     finally {
         screen.running = false;
@@ -1941,6 +2033,60 @@ async function handleInputKey(key, screen, state, done) {
 function handleResultsKey(key, screen, state, done) {
     const { rows } = termSize();
     const viewH = Math.max(3, rows - 10);
+    // Profile list inline shortcuts: u=use, s=show, d=delete
+    if (screen.group.name === "profile" &&
+        screen.cmd.name === "list" &&
+        screen.output.type === "list") {
+        // Clear stale message on any key in this context
+        screen.message = "";
+        if (key === "u" || key === "U") {
+            const item = screen.output.items[screen.cursor];
+            const name = item?.name;
+            if (name && useProfile(name)) {
+                state.profile = name;
+                state.profileInfo = buildProfileInfoEntries(name);
+                const items = rebuildProfileListItems();
+                screen.output = { type: "list", items, columns: screen.output.columns, total: items.length };
+                screen.message = `✓ Active profile: ${name}`;
+            }
+            else if (name) {
+                screen.message = `Profile "${name}" not found`;
+            }
+            render(state);
+            return;
+        }
+        if (key === "s" || key === "S") {
+            const item = screen.output.items[screen.cursor];
+            if (item) {
+                state.stack.push({
+                    kind: "detail",
+                    group: screen.group,
+                    cmd: screen.cmd,
+                    item,
+                    label: String(item.name ?? "profile"),
+                    cursor: 0,
+                    scroll: 0,
+                });
+            }
+            render(state);
+            return;
+        }
+        if (key === "d" || key === "D") {
+            const item = screen.output.items[screen.cursor];
+            const name = item?.name;
+            if (name && deleteProfile(name)) {
+                const items = rebuildProfileListItems();
+                screen.output = { type: "list", items, columns: screen.output.columns, total: items.length };
+                screen.cursor = Math.min(screen.cursor, Math.max(0, items.length - 1));
+                screen.message = `✓ Deleted profile "${name}"`;
+            }
+            else if (name) {
+                screen.message = `Cannot delete "${name}" (modeler profiles are read-only)`;
+            }
+            render(state);
+            return;
+        }
+    }
     // r/R toggles raw view; u/U toggles curl view — mutually exclusive
     if (key === "r" || key === "R") {
         screen.rawView = !screen.rawView;
@@ -2381,6 +2527,7 @@ function handleFollowupKey(key, screen, state, done) {
                     scroll: 0,
                     editing: false,
                     error: "",
+                    errorRaw: null,
                     running: false,
                 });
             }
@@ -2431,6 +2578,29 @@ function handleJsonEditorKey(key, screen, state, done) {
                 entry.valCursor = cur;
             }
         };
+        // Key cycling for key column when fieldSpecs are available
+        if (activeIsKey && screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+            const available = getAvailableFieldSpecs(screen.cursor, screen.entries, screen.fieldSpecs);
+            if (available.length > 0) {
+                if (key === "\x1b[A" || key === "\x1b[B") {
+                    const curIdx = available.findIndex((s) => s.name === entry.key);
+                    let nextIdx;
+                    if (key === "\x1b[A") {
+                        nextIdx = curIdx <= 0 ? available.length - 1 : curIdx - 1;
+                    }
+                    else {
+                        nextIdx = curIdx < 0 || curIdx >= available.length - 1 ? 0 : curIdx + 1;
+                    }
+                    const newSpec = available[nextIdx];
+                    if (newSpec) {
+                        entry.key = newSpec.name;
+                        entry.keyCursor = entry.key.length;
+                    }
+                    render(state);
+                    return;
+                }
+            }
+        }
         // Enum cycling for value column of a known enum field
         const valSpec = !activeIsKey ? getFieldSpec(entry.key, screen.fieldSpecs) : undefined;
         const enumVals = valSpec?.enum;
@@ -2553,8 +2723,17 @@ function handleJsonEditorKey(key, screen, state, done) {
         case "\r":
         case "\n":
             if (isAddRow) {
-                // Add a new entry and start editing its key
-                screen.entries.push({ key: "", keyCursor: 0, val: "", valCursor: 0 });
+                // Add a new entry; pre-seed key from first available field spec if available
+                const newEntry = { key: "", keyCursor: 0, val: "", valCursor: 0 };
+                if (screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+                    const available = getAvailableFieldSpecs(null, screen.entries, screen.fieldSpecs);
+                    const firstSpec = available[0];
+                    if (firstSpec) {
+                        newEntry.key = firstSpec.name;
+                        newEntry.keyCursor = firstSpec.name.length;
+                    }
+                }
+                screen.entries.push(newEntry);
                 screen.cursor = screen.entries.length - 1;
                 screen.col = "key";
                 screen.editing = true;
@@ -2572,18 +2751,23 @@ function handleJsonEditorKey(key, screen, state, done) {
             }
             break;
         case "a":
-        case "A":
-            // Insert new entry after cursor and start editing
-            screen.entries.splice(screen.cursor + 1, 0, {
-                key: "",
-                keyCursor: 0,
-                val: "",
-                valCursor: 0,
-            });
+        case "A": {
+            // Insert new entry after cursor; pre-seed key from first available field spec
+            const addEntry = { key: "", keyCursor: 0, val: "", valCursor: 0 };
+            if (screen.fieldSpecs && screen.fieldSpecs.length > 0) {
+                const available = getAvailableFieldSpecs(null, screen.entries, screen.fieldSpecs);
+                const firstSpec = available[0];
+                if (firstSpec) {
+                    addEntry.key = firstSpec.name;
+                    addEntry.keyCursor = firstSpec.name.length;
+                }
+            }
+            screen.entries.splice(screen.cursor + 1, 0, addEntry);
             screen.cursor = Math.min(screen.cursor + 1, screen.entries.length - 1);
             screen.col = "key";
             screen.editing = true;
             break;
+        }
         case "d":
         case "D":
             if (!isAddRow && screen.entries.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/cli",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Command-line interface for Camunda 8 — deploy, manage, and monitor processes from the terminal",
   "type": "module",
   "bin": {
@@ -16,11 +16,11 @@
   },
   "dependencies": {
     "@bpmnkit/api": "0.0.13",
-    "@bpmnkit/ascii": "0.0.15",
+    "@bpmnkit/ascii": "0.0.16",
     "@bpmnkit/connector-gen": "0.0.8",
-    "@bpmnkit/core": "0.0.15",
-    "@bpmnkit/engine": "0.1.14",
-    "@bpmnkit/profiles": "0.0.10"
+    "@bpmnkit/core": "0.0.16",
+    "@bpmnkit/engine": "0.1.15",
+    "@bpmnkit/profiles": "0.0.11"
   },
   "publishConfig": {
     "access": "public"