@amaster.ai/runtime-cli 1.1.9 → 1.1.11

package/dist/index.js

@@ -1,10 +1,11 @@
 import { existsSync, rmSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, resolve } from 'path';
+import { join, resolve, basename } from 'path';
 import { homedir } from 'os';
 import { Command, Option } from 'commander';
-import chalk7 from 'chalk';
+import chalk3 from 'chalk';
 import { createClient } from '@amaster.ai/client';
 import ora from 'ora';
+import { File } from 'buffer';
 import yaml from 'yaml';
 
 var __defProp = Object.defineProperty;
@@ -327,9 +328,9 @@ async function login(appCode, options) {
     const appConfig = getAppConfig(appCode);
     if (!appConfig) {
       spinner.fail(`App not configured: ${appCode}`);
-      console.error(chalk7.red(`
+      console.error(chalk3.red(`
 \u274C App not found: ${appCode}`));
-      console.log(chalk7.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
+      console.log(chalk3.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
       process.exit(1);
     }
     let username = options.username;
@@ -378,7 +379,7 @@ async function login(appCode, options) {
     const result = await client.auth.login(loginParams);
     if (result.error) {
       spinner.fail("Login failed");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     const loginData = result.data;
@@ -412,16 +413,16 @@ async function login(appCode, options) {
         format: options.format,
         pretty: () => {
           console.log(
-            chalk7.green(
+            chalk3.green(
               `
 Welcome, ${loginData.user?.displayName || loginData.user?.email || loginData.user?.username || email}!`
             )
           );
-          console.log(chalk7.gray(`App: ${appCode}`));
-          console.log(chalk7.gray(`URL: ${appConfig.baseURL}`));
+          console.log(chalk3.gray(`App: ${appCode}`));
+          console.log(chalk3.gray(`URL: ${appConfig.baseURL}`));
           if (expiresAt) {
             const expires = new Date(expiresAt);
-            console.log(chalk7.gray(`Session expires: ${expires.toLocaleString()}`));
+            console.log(chalk3.gray(`Session expires: ${expires.toLocaleString()}`));
           }
         }
       }
@@ -457,7 +458,7 @@ async function logout(appCode, options = {}) {
       {
         format: options.format,
         pretty: () => {
-          console.log(chalk7.green(`Logged out from ${appCode}`));
+          console.log(chalk3.green(`Logged out from ${appCode}`));
         }
       }
     );
@@ -473,7 +474,7 @@ async function getMe(getClient, options = {}) {
     const result = await client.auth.getMe();
     if (result.error) {
       spinner.fail("Failed to fetch user info");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("User info retrieved");
@@ -481,11 +482,11 @@ async function getMe(getClient, options = {}) {
     renderOutput(user, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue("\n\u{1F464} User Profile\n"));
-        console.log(`  ${chalk7.bold("UID:")} ${user?.uid}`);
-        console.log(`  ${chalk7.bold("Email:")} ${user?.email}`);
-        console.log(`  ${chalk7.bold("Name:")} ${user?.displayName || user?.username || "N/A"}`);
-        console.log(`  ${chalk7.bold("Status:")} ${user?.isActive ? "Active" : "Inactive"}`);
+        console.log(chalk3.blue("\n\u{1F464} User Profile\n"));
+        console.log(`  ${chalk3.bold("UID:")} ${user?.uid}`);
+        console.log(`  ${chalk3.bold("Email:")} ${user?.email}`);
+        console.log(`  ${chalk3.bold("Name:")} ${user?.displayName || user?.username || "N/A"}`);
+        console.log(`  ${chalk3.bold("Status:")} ${user?.isActive ? "Active" : "Inactive"}`);
       }
     });
   } catch (error) {
@@ -615,7 +616,7 @@ function exitWithCommandError(spinner, failureMessage, error) {
   spinner.fail(failureMessage);
   const details = error instanceof Error ? error.message : String(error);
   if (details) {
-    console.error(chalk7.red(details));
+    console.error(chalk3.red(details));
   }
   process.exit(1);
 }
@@ -667,14 +668,20 @@ async function listEntities(client, options) {
   try {
     const entityClient = client.entity;
     const query = buildListQueryParams(options);
+    const paginationParams = {};
+    if (options.page !== void 0) {
+      paginationParams.page = options.page;
+    }
+    if (options.pageSize !== void 0) {
+      paginationParams.perPage = options.pageSize;
+    }
     const result = await entityClient.list(options.namespace, options.entity, {
       ...query,
-      page: options.page || 1,
-      perPage: options.pageSize || 10
+      ...paginationParams
     });
     if (result.error) {
       spinner.fail("Failed to fetch entities");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.stop();
@@ -694,12 +701,12 @@ async function listEntities(client, options) {
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue(`
+        console.log(chalk3.blue(`
 \u{1F4E6} ${options.entity} in ${options.namespace}`));
-        console.log(chalk7.gray(`\u5171 ${total} \u6761\u8BB0\u5F55:
+        console.log(chalk3.gray(`\u5171 ${total} \u6761\u8BB0\u5F55:
 `));
         if (items.length === 0) {
-          console.log(chalk7.gray("  \u6682\u65E0\u6570\u636E"));
+          console.log(chalk3.gray("  \u6682\u65E0\u6570\u636E"));
           return;
         }
         const firstItem = items[0];
@@ -719,7 +726,7 @@ async function listEntities(client, options) {
         });
         const headerLine = keys.map((key) => {
           const width = widths[key] ?? 0;
-          return chalk7.bold(key.slice(0, width).padEnd(width));
+          return chalk3.bold(key.slice(0, width).padEnd(width));
         }).join("\u2502");
         console.log("  " + headerLine);
         console.log("  " + keys.map((key) => "\u2500".repeat(widths[key] ?? 0)).join("\u253C"));
@@ -735,7 +742,7 @@ async function listEntities(client, options) {
         }
         console.log();
         if (items.length < total) {
-          console.log(chalk7.gray(`  ... \u8FD8\u6709 ${total - items.length} \u6761\u8BB0\u5F55`));
+          console.log(chalk3.gray(`  ... \u8FD8\u6709 ${total - items.length} \u6761\u8BB0\u5F55`));
         }
       }
     });
@@ -750,14 +757,14 @@ async function getEntity(client, options) {
     const result = await entityClient.get(options.namespace, options.entity, options.id);
     if (result.error) {
       spinner.fail("Failed to fetch entity");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Entity retrieved");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue(`
+        console.log(chalk3.blue(`
 \u{1F4C4} ${options.entity}
 `));
         console.log(JSON.stringify(result.data, null, 2));
@@ -775,14 +782,14 @@ async function createEntity(client, options) {
     const result = await entityClient.create(options.namespace, options.entity, data);
     if (result.error) {
       spinner.fail("Failed to create entity");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Entity created");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green("\nCreated entity:"));
+        console.log(chalk3.green("\nCreated entity:"));
         console.log(JSON.stringify(result.data, null, 2));
       }
     });
@@ -798,14 +805,14 @@ async function updateEntity(client, options) {
     const result = await entityClient.update(options.namespace, options.entity, options.id, data);
     if (result.error) {
       spinner.fail("Failed to update entity");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Entity updated");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green("\nUpdated entity:"));
+        console.log(chalk3.green("\nUpdated entity:"));
         console.log(JSON.stringify(result.data, null, 2));
       }
     });
@@ -820,7 +827,7 @@ async function deleteEntity(client, options) {
     const result = await entityClient.delete(options.namespace, options.entity, options.id);
     if (result.error) {
       spinner.fail("Failed to delete entity");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Entity deleted");
@@ -834,7 +841,7 @@ async function deleteEntity(client, options) {
       {
         format: options.format,
         pretty: () => {
-          console.log(chalk7.green(`
+          console.log(chalk3.green(`
 Deleted ${options.entity} with ID: ${options.id}`));
         }
       }
@@ -851,14 +858,14 @@ async function listEntityOptions(client, options) {
     const result = await entityClient.options(options.namespace, options.entity, fields);
     if (result.error) {
       spinner.fail("Failed to fetch entity options");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed(`Found ${result.data?.length || 0} options`);
     renderOutput(result.data || [], {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue(`
+        console.log(chalk3.blue(`
 \u{1F9FE} ${options.entity} options
 `));
         console.log(JSON.stringify(result.data || [], null, 2));
@@ -881,14 +888,14 @@ async function bulkUpdateEntities(client, options) {
     const result = await entityClient.bulkUpdate(options.namespace, options.entity, items);
     if (result.error) {
       spinner.fail("Failed to bulk update entities");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed(`Updated ${items.length} entities`);
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green(`
+        console.log(chalk3.green(`
 Bulk updated ${items.length} ${options.entity} records:`));
         console.log(JSON.stringify(result.data, null, 2));
       }
@@ -905,7 +912,7 @@ async function bulkDeleteEntities(client, options) {
     const result = await entityClient.bulkDelete(options.namespace, options.entity, ids);
     if (result.error) {
       spinner.fail("Failed to bulk delete entities");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed(`Deleted ${ids.length} entities`);
@@ -920,7 +927,7 @@ async function bulkDeleteEntities(client, options) {
       {
         format: options.format,
         pretty: () => {
-          console.log(chalk7.green(`
+          console.log(chalk3.green(`
 Deleted ${ids.length} ${options.entity} records.`));
         }
       }
@@ -929,14 +936,256 @@ Deleted ${ids.length} ${options.entity} records.`));
     exitWithCommandError(spinner, "Failed to bulk delete entities", error);
   }
 }
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveInputSource2(input) {
+  if (!input.startsWith("@")) {
+    return input;
+  }
+  const filePath = input.slice(1);
+  if (!filePath) {
+    throw new Error("File path is required after '@'.");
+  }
+  return readFileSync(filePath, "utf8");
+}
+function parseJsonInput2(input, label) {
+  const source = resolveInputSource2(input).trim();
+  if (!source) {
+    throw new Error(`${label} is required.`);
+  }
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${label}: ${reason}`);
+  }
+}
+async function promptForJson2(message, defaultValue) {
+  const { default: inquirer } = await import('inquirer');
+  const { jsonData } = await inquirer.prompt([
+    {
+      type: "editor",
+      name: "jsonData",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return jsonData;
+}
+async function loadJsonObjectInput2(input, label, promptMessage) {
+  const source = input ?? await promptForJson2(promptMessage, "{}");
+  const value = parseJsonInput2(source, label);
+  if (!isPlainObject3(value)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return value;
+}
+function loadOptionalJsonObjectInput2(input, label) {
+  if (!input) {
+    return {};
+  }
+  const value = parseJsonInput2(input, label);
+  if (!isPlainObject3(value)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return value;
+}
+function exitWithCommandError2(spinner, failureMessage, error) {
+  spinner.fail(failureMessage);
+  const details = error instanceof Error ? error.message : String(error);
+  if (details) {
+    console.error(chalk3.red(details));
+  }
+  process.exit(1);
+}
+function extractClientErrorMessage(error) {
+  return error?.message || "Unknown BPM client error.";
+}
+function exitWithClientError(spinner, failureMessage, error, diagnosticMessage) {
+  spinner.fail(failureMessage);
+  console.error(chalk3.red(diagnosticMessage || extractClientErrorMessage(error)));
+  process.exit(1);
+}
+function inspectStartEventFormConfiguration(bpmnXml) {
+  const startEventMatches = bpmnXml.match(/<[^>]*startEvent\b[\s\S]*?(?:<\/[^>]*startEvent>|\/>)/g) || [];
+  return {
+    startEventCount: startEventMatches.length,
+    hasFormKey: startEventMatches.some((eventXml) => /\bformKey\s*=/.test(eventXml)),
+    hasCamundaFormRef: startEventMatches.some((eventXml) => /\bcamunda:formRef\s*=/.test(eventXml)),
+    hasCamundaFormData: startEventMatches.some((eventXml) => /<camunda:formData\b/.test(eventXml))
+  };
+}
+async function diagnoseTaskFormSchemaError(bpmClient, taskId, originalMessage) {
+  try {
+    const taskFormResult = await bpmClient.getTaskForm(taskId);
+    if (taskFormResult?.error || !taskFormResult?.data) {
+      return null;
+    }
+    const key = typeof taskFormResult.data.key === "string" && taskFormResult.data.key.length > 0 ? taskFormResult.data.key : null;
+    const camundaFormRef = taskFormResult.data.camundaFormRef;
+    if (!camundaFormRef && key?.includes("/rendered-form")) {
+      return [
+        `Task '${taskId}' uses an embedded/generated Camunda form (${key}) rather than a schema-backed form.`,
+        "`bpm task-form-schema` is expected to return 404 in this case.",
+        "Use `bpm task-form`, `bpm task-rendered-form`, or `bpm task-form-variables` instead."
+      ].join(" ");
+    }
+    if (!camundaFormRef && !key) {
+      return [
+        `Task '${taskId}' does not expose schema-backed form metadata.`,
+        "Use `bpm task-form` or `bpm task-form-variables` instead."
+      ].join(" ");
+    }
+    if (camundaFormRef) {
+      return [
+        `Task '${taskId}' appears to reference a Camunda form via camundaFormRef, but the backend returned 404 for /form-schema.`,
+        `Original error: ${originalMessage}`
+      ].join(" ");
+    }
+  } catch {
+  }
+  return null;
+}
+async function diagnoseStartFormError(bpmClient, processKey, originalMessage) {
+  let tenantId = null;
+  let startFormConfig = null;
+  try {
+    const definitionsResult = await bpmClient.getProcessDefinitions({ key: processKey, latestVersion: true });
+    if (!definitionsResult?.error && Array.isArray(definitionsResult?.data) && definitionsResult.data.length > 0) {
+      const latestDefinition = definitionsResult.data[0];
+      tenantId = latestDefinition?.tenantId || null;
+    }
+  } catch {
+  }
+  try {
+    const xmlResult = await bpmClient.getProcessXml(processKey);
+    if (!xmlResult?.error && typeof xmlResult?.data?.bpmn20Xml === "string") {
+      startFormConfig = inspectStartEventFormConfiguration(xmlResult.data.bpmn20Xml);
+    }
+  } catch {
+  }
+  if (startFormConfig && !startFormConfig.hasFormKey && !startFormConfig.hasCamundaFormRef && !startFormConfig.hasCamundaFormData) {
+    const tenantHint = tenantId && /no tenant-id/i.test(originalMessage) ? ` The process definition is tenant-scoped ('${tenantId}'), and this endpoint also appears to resolve by key without tenant context.` : "";
+    return [
+      `Process '${processKey}' exists, but its start event does not define formKey, camunda:formRef, or camunda:formData.`,
+      "`bpm start-form*` endpoints are expected to fail for this model.",
+      `Use \`bpm xml ${processKey}\` to inspect the BPMN or configure a start form first.${tenantHint}`
+    ].join(" ");
+  }
+  if (tenantId && /no tenant-id/i.test(originalMessage)) {
+    return [
+      `Process '${processKey}' exists under tenant '${tenantId}', but the backend start-form endpoint resolved the process definition by key without tenant-id.`,
+      "Current CLI/SDK sends only processKey for this endpoint.",
+      "This is likely a backend multi-tenant lookup limitation rather than a wrong CLI parameter."
+    ].join(" ");
+  }
+  if (/formKey/i.test(originalMessage) && /camunda:formRef/i.test(originalMessage)) {
+    return [
+      `Process '${processKey}' does not expose a deployed start form because neither formKey nor camunda:formRef is configured on the start event.`,
+      "If you need a start form, add formKey or camunda:formRef in the BPMN model."
+    ].join(" ");
+  }
+  return null;
+}
+function buildProcessDefinitionQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "process query params");
+  if (options.key) params.key = options.key;
+  if (options.name) params.name = options.name;
+  if (options.latestVersion !== void 0) params.latestVersion = options.latestVersion;
+  if (options.active !== void 0) params.active = options.active;
+  if (options.suspended !== void 0) params.suspended = options.suspended;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  return params;
+}
+function buildTaskQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "task query params");
+  if (options.processInstanceId) params.processInstanceId = options.processInstanceId;
+  if (options.assignee) params.assignee = options.assignee;
+  if (options.candidateUser) params.candidateUser = options.candidateUser;
+  if (options.candidateGroup) params.candidateGroup = options.candidateGroup;
+  if (options.name) params.name = options.name;
+  if (options.nameLike) params.nameLike = options.nameLike;
+  if (options.taskDefinitionKey) params.taskDefinitionKey = options.taskDefinitionKey;
+  if (options.firstResult !== void 0) params.firstResult = options.firstResult;
+  if (options.maxResults !== void 0) params.maxResults = options.maxResults;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  return params;
+}
+function buildProcessInstanceQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "process instance query params");
+  if (options.processDefinitionKey) params.processDefinitionKey = options.processDefinitionKey;
+  if (options.active !== void 0) params.active = options.active;
+  if (options.firstResult !== void 0) params.firstResult = options.firstResult;
+  if (options.maxResults !== void 0) params.maxResults = options.maxResults;
+  return params;
+}
+function buildHistoryTaskQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "history task query params");
+  if (options.taskAssignee) params.taskAssignee = options.taskAssignee;
+  if (options.processInstanceId) params.processInstanceId = options.processInstanceId;
+  if (options.finished !== void 0) params.finished = options.finished;
+  if (options.unfinished !== void 0) params.unfinished = options.unfinished;
+  if (options.scope) params.scope = options.scope;
+  if (options.firstResult !== void 0) params.firstResult = options.firstResult;
+  if (options.maxResults !== void 0) params.maxResults = options.maxResults;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  return params;
+}
+function buildHistoryProcessInstanceQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "history process instance query params");
+  if (options.startedBy) params.startedBy = options.startedBy;
+  if (options.finished !== void 0) params.finished = options.finished;
+  if (options.unfinished !== void 0) params.unfinished = options.unfinished;
+  if (options.processDefinitionKey) params.processDefinitionKey = options.processDefinitionKey;
+  if (options.scope) params.scope = options.scope;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  if (options.firstResult !== void 0) params.firstResult = options.firstResult;
+  if (options.maxResults !== void 0) params.maxResults = options.maxResults;
+  return params;
+}
+function buildHistoryActivityQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "history activity query params");
+  if (options.processInstanceId) params.processInstanceId = options.processInstanceId;
+  if (options.activityId) params.activityId = options.activityId;
+  if (options.activityType) params.activityType = options.activityType;
+  if (options.finished !== void 0) params.finished = options.finished;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  return params;
+}
+function buildHistoryVariableQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "history variable query params");
+  if (options.processInstanceId) params.processInstanceId = options.processInstanceId;
+  if (options.variableName) params.variableName = options.variableName;
+  if (options.deserializeValues !== void 0) params.deserializeValues = options.deserializeValues;
+  return params;
+}
+function buildUserOperationLogQueryParams(options) {
+  const params = loadOptionalJsonObjectInput2(options.query, "user operation log query params");
+  if (options.processInstanceId) params.processInstanceId = options.processInstanceId;
+  if (options.taskId) params.taskId = options.taskId;
+  if (options.userId) params.userId = options.userId;
+  if (options.operationType) params.operationType = options.operationType;
+  if (options.sortBy) params.sortBy = options.sortBy;
+  if (options.sortOrder) params.sortOrder = options.sortOrder;
+  if (options.firstResult !== void 0) params.firstResult = options.firstResult;
+  if (options.maxResults !== void 0) params.maxResults = options.maxResults;
+  return params;
+}
 async function listProcesses(client, options = {}) {
   const spinner = createSpinner("Fetching process definitions...", options.format);
   try {
     const bpmClient = client.bpm;
-    const result = await bpmClient.getProcessDefinitions();
+    const params = buildProcessDefinitionQueryParams(options);
+    const result = await bpmClient.getProcessDefinitions(params);
     if (result.error) {
       spinner.fail("Failed to fetch processes");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed(`Found ${result.data?.length || 0} process definitions`);
@@ -944,169 +1193,1045 @@ async function listProcesses(client, options = {}) {
     renderOutput(processes, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue("\n\u{1F4CA} Process Definitions\n"));
+        console.log(chalk3.blue("\n\u{1F4CA} Process Definitions\n"));
         for (const proc of processes) {
-          console.log(`  ${chalk7.green("\u2022")} ${chalk7.bold(proc.key)}`);
-          console.log(`    ${chalk7.gray("Name:")} ${proc.name || "N/A"}`);
-          console.log(`    ${chalk7.gray("Version:")} ${proc.version || "N/A"}`);
+          console.log(`  ${chalk3.green("\u2022")} ${chalk3.bold(proc.key)}`);
+          console.log(`    ${chalk3.gray("ID:")} ${proc.id || "N/A"}`);
+          console.log(`    ${chalk3.gray("Name:")} ${proc.name || "N/A"}`);
+          console.log(`    ${chalk3.gray("Version:")} ${proc.version || "N/A"}`);
+          console.log(`    ${chalk3.gray("Suspended:")} ${proc.suspended ? "Yes" : "No"}`);
           console.log();
         }
       }
     });
   } catch (error) {
-    spinner.fail("Failed to fetch processes");
-    throw error;
+    exitWithCommandError2(spinner, "Failed to fetch processes", error);
+  }
+}
+async function getProcessXml(client, options) {
+  const spinner = createSpinner(`Fetching BPMN XML for ${options.key}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getProcessXml(options.key);
+    if (result.error) {
+      spinner.fail("Failed to fetch process XML");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Process XML retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue(`
+\u{1F4C4} BPMN XML: ${options.key}
+`));
+        console.log(result.data?.bpmn20Xml || "");
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch process XML", error);
   }
 }
 async function startProcess(client, options) {
   const spinner = createSpinner(`Starting process: ${options.key}...`, options.format);
   try {
     const bpmClient = client.bpm;
-    const variables = options.variables ? JSON.parse(options.variables) : {};
-    const result = await bpmClient.startProcess({
-      processKey: options.key,
-      variables
-    });
+    const variables = loadOptionalJsonObjectInput2(options.variables, "process variables");
+    const result = await bpmClient.startProcess(options.key, variables);
     if (result.error) {
       spinner.fail("Failed to start process");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Process started");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green("\nProcess Instance:"));
-        console.log(`  ${chalk7.bold("ID:")} ${result.data?.id}`);
-        console.log(`  ${chalk7.bold("Definition ID:")} ${result.data?.definitionId}`);
-        console.log(`  ${chalk7.bold("Business Key:")} ${result.data?.businessKey || "N/A"}`);
-        console.log(`  ${chalk7.bold("Status:")} ${result.data?.suspended ? "Suspended" : "Active"}`);
+        console.log(chalk3.green("\nProcess Instance:"));
+        console.log(`  ${chalk3.bold("ID:")} ${result.data?.id}`);
+        console.log(`  ${chalk3.bold("Definition ID:")} ${result.data?.definitionId}`);
+        console.log(`  ${chalk3.bold("Business Key:")} ${result.data?.businessKey || "N/A"}`);
+        console.log(`  ${chalk3.bold("Status:")} ${result.data?.suspended ? "Suspended" : "Active"}`);
       }
     });
   } catch (error) {
-    spinner.fail("Failed to start process");
-    throw error;
+    exitWithCommandError2(spinner, "Failed to start process", error);
   }
 }
-async function listTasks(client, options) {
-  const spinner = createSpinner("Fetching tasks...", options.format);
+async function listProcessInstances(client, options = {}) {
+  const spinner = createSpinner("Fetching process instances...", options.format);
   try {
     const bpmClient = client.bpm;
-    const params = {};
-    if (options.assignee) {
-      params.assignee = options.assignee;
-    }
-    const result = await bpmClient.getMyTasks(params);
+    const params = buildProcessInstanceQueryParams(options);
+    const result = await bpmClient.getProcessInstances(params);
     if (result.error) {
-      spinner.fail("Failed to fetch tasks");
-      console.error(chalk7.red(result.error.message));
+      spinner.fail("Failed to fetch process instances");
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
-    spinner.succeed(`Found ${result.data?.length || 0} tasks`);
-    const tasks = result.data || [];
-    renderOutput(tasks, {
+    spinner.succeed(`Found ${result.data?.length || 0} process instances`);
+    const instances = result.data || [];
+    renderOutput(instances, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue("\n\u{1F4DD} Tasks\n"));
-        for (const task of tasks) {
-          console.log(`  ${chalk7.green("\u2022")} ${chalk7.bold(task.name || task.id)}`);
-          console.log(`    ${chalk7.gray("ID:")} ${task.id}`);
-          console.log(`    ${chalk7.gray("Assignee:")} ${task.assignee || "Unassigned"}`);
-          console.log(`    ${chalk7.gray("Created:")} ${task.created || "N/A"}`);
+        console.log(chalk3.blue("\n\u{1F504} Process Instances\n"));
+        for (const instance of instances) {
+          console.log(`  ${chalk3.green("\u2022")} ${chalk3.bold(instance.id)}`);
+          console.log(`    ${chalk3.gray("Definition:")} ${instance.definitionId || "N/A"}`);
+          console.log(`    ${chalk3.gray("Business Key:")} ${instance.businessKey || "N/A"}`);
+          console.log(
+            `    ${chalk3.gray("Status:")} ${instance.ended ? "Ended" : instance.suspended ? "Suspended" : "Active"}`
+          );
           console.log();
         }
       }
     });
   } catch (error) {
-    spinner.fail("Failed to fetch tasks");
-    throw error;
+    exitWithCommandError2(spinner, "Failed to fetch process instances", error);
   }
 }
-async function completeTask(client, options) {
-  const spinner = createSpinner(`Completing task: ${options.id}...`, options.format);
+async function getProcessInstance(client, options) {
+  const spinner = createSpinner("Fetching process instance...", options.format);
   try {
     const bpmClient = client.bpm;
-    const variables = options.variables ? JSON.parse(options.variables) : {};
-    const result = await bpmClient.completeTask(options.id, { variables });
+    const result = await bpmClient.getProcessInstance(options.id);
     if (result.error) {
-      spinner.fail("Failed to complete task");
-      console.error(chalk7.red(result.error.message));
+      spinner.fail("Failed to fetch process instance");
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
-    spinner.succeed("Task completed");
+    spinner.succeed("Process instance retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4CA} Process Instance\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch process instance", error);
+  }
+}
+async function getActivityInstanceTree(client, options) {
+  const spinner = createSpinner("Fetching activity instance tree...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getActivityInstanceTree(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch activity instance tree");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Activity instance tree retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F333} Activity Instance Tree\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch activity instance tree", error);
+  }
+}
+async function getActiveActivities(client, options) {
+  const spinner = createSpinner("Fetching active activities...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getActiveActivities(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch active activities");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const activities = Array.isArray(result.data) ? result.data : [];
+    spinner.succeed(`Found ${activities.length} active activities`);
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u26A1 Active Activities\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch active activities", error);
+  }
+}
+async function getRuntimeVariables(client, options) {
+  const spinner = createSpinner("Fetching runtime variables...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getRuntimeVariables(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch runtime variables");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Runtime variables retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9EE} Runtime Variables\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch runtime variables", error);
+  }
+}
+async function getProcessVariables(client, options) {
+  const spinner = createSpinner("Fetching process variables...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getProcessVariables({
+      processInstanceId: options.id,
+      variableName: options.name
+    });
+    if (result.error) {
+      spinner.fail("Failed to fetch process variables");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed(`Found ${result.data?.length || 0} variables`);
+    renderOutput(result.data || [], {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9FE} Process Variables\n"));
+        console.log(JSON.stringify(result.data || [], null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch process variables", error);
+  }
+}
+async function deleteProcessInstance(client, options) {
+  const spinner = createSpinner(`Deleting process instance: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.deleteProcessInstance(options.id, {
+      skipCustomListeners: options.skipCustomListeners
+    });
+    if (result.error) {
+      spinner.fail("Failed to delete process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Process instance deleted");
     renderOutput(
       {
         id: options.id,
-        completed: true
+        deleted: true,
+        skipCustomListeners: !!options.skipCustomListeners
       },
       {
         format: options.format,
         pretty: () => {
-          console.log(chalk7.green(`Completed task: ${options.id}`));
+          console.log(chalk3.green(`Deleted process instance: ${options.id}`));
         }
       }
     );
   } catch (error) {
-    spinner.fail("Failed to complete task");
-    throw error;
+    exitWithCommandError2(spinner, "Failed to delete process instance", error);
+  }
+}
+async function suspendProcessInstance(client, options) {
+  const spinner = createSpinner(`Suspending process instance: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.suspendProcessInstance(options.id);
+    if (result.error) {
+      spinner.fail("Failed to suspend process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Process instance suspended");
+    renderOutput(
+      {
+        id: options.id,
+        suspended: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Suspended process instance: ${options.id}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to suspend process instance", error);
+  }
+}
+async function activateProcessInstance(client, options) {
+  const spinner = createSpinner(`Activating process instance: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.activateProcessInstance(options.id);
+    if (result.error) {
+      spinner.fail("Failed to activate process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Process instance activated");
+    renderOutput(
+      {
+        id: options.id,
+        activated: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Activated process instance: ${options.id}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to activate process instance", error);
+  }
+}
+async function modifyProcessInstance(client, options) {
+  const spinner = createSpinner(`Modifying process instance: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const modification = await loadJsonObjectInput2(
+      options.modification,
+      "process modification",
+      "Enter process modification JSON:"
+    );
+    const result = await bpmClient.modifyProcessInstance(options.id, modification);
+    if (result.error) {
+      spinner.fail("Failed to modify process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Process instance modified");
+    renderOutput(
+      {
+        id: options.id,
+        modified: true,
+        modification
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Modified process instance: ${options.id}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to modify process instance", error);
+  }
+}
+async function listTasks(client, options) {
+  const spinner = createSpinner("Fetching tasks...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildTaskQueryParams(options);
+    const result = await bpmClient.getTasks(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch tasks");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed(`Found ${result.data?.length || 0} tasks`);
+    const tasks = result.data || [];
+    renderOutput(tasks, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DD} Tasks\n"));
+        for (const task of tasks) {
+          console.log(`  ${chalk3.green("\u2022")} ${chalk3.bold(task.name || task.id)}`);
+          console.log(`    ${chalk3.gray("ID:")} ${task.id}`);
+          console.log(`    ${chalk3.gray("Assignee:")} ${task.assignee || "Unassigned"}`);
+          console.log(`    ${chalk3.gray("Process Instance:")} ${task.processInstanceId || "N/A"}`);
+          console.log(`    ${chalk3.gray("Created:")} ${task.created || "N/A"}`);
+          console.log();
+        }
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch tasks", error);
+  }
+}
+async function getTask(client, options) {
+  const spinner = createSpinner(`Fetching task: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTask(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch task");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DD} Task\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch task", error);
+  }
+}
+async function getTaskCount(client, options) {
+  const spinner = createSpinner("Fetching task count...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildTaskQueryParams(options);
+    const result = await bpmClient.getTaskCount(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch task count");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task count retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.green(`Task count: ${result.data?.count ?? 0}`));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch task count", error);
+  }
+}
+async function completeTask(client, options) {
+  const spinner = createSpinner(`Completing task: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const variables = loadOptionalJsonObjectInput2(options.variables, "task variables");
+    const result = await bpmClient.completeTask(options.id, variables);
+    if (result.error) {
+      spinner.fail("Failed to complete task");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task completed");
+    renderOutput(
+      {
+        id: options.id,
+        completed: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Completed task: ${options.id}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to complete task", error);
+  }
+}
+async function delegateTask(client, options) {
+  const spinner = createSpinner(`Delegating task: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.delegateTask(options.id, options.userId);
+    if (result.error) {
+      spinner.fail("Failed to delegate task");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task delegated");
+    renderOutput(
+      {
+        id: options.id,
+        userId: options.userId,
+        delegated: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Delegated task ${options.id} to ${options.userId}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to delegate task", error);
+  }
+}
+async function getTaskForm(client, options) {
+  const spinner = createSpinner("Fetching task form...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTaskForm(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch task form");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task form retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9E9} Task Form\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch task form", error);
+  }
+}
+async function getTaskFormSchema(client, options) {
+  const spinner = createSpinner("Fetching task form schema...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTaskFormSchema(
+      options.id,
+      options.redirect ? { redirect: options.redirect } : void 0
+    );
+    if (result.error) {
+      const diagnostic = await diagnoseTaskFormSchemaError(
+        bpmClient,
+        options.id,
+        extractClientErrorMessage(result.error)
+      );
+      exitWithClientError(spinner, "Failed to fetch task form schema", result.error, diagnostic);
+    }
+    spinner.succeed("Task form schema retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9E9} Task Form Schema\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch task form schema", error);
+  }
+}
+async function getTaskFormVariables(client, options) {
+  const spinner = createSpinner("Fetching task form variables...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTaskFormVariables(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch task form variables");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Task form variables retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9EE} Task Form Variables\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch task form variables", error);
+  }
+}
+async function getTaskRenderedForm(client, options) {
+  const spinner = createSpinner("Fetching rendered task form...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTaskRenderedForm(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch rendered task form");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Rendered task form retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9FE} Rendered Task Form\n"));
+        console.log(result.data || "");
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch rendered task form", error);
+  }
+}
+async function getTaskDeployedForm(client, options) {
+  const spinner = createSpinner("Fetching deployed task form...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getTaskDeployedForm(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch deployed task form");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("Deployed task form retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F9FE} Deployed Task Form\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch deployed task form", error);
+  }
+}
+async function getStartFormInfo(client, options) {
+  const spinner = createSpinner("Fetching start form info...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getStartFormInfo(options.key);
+    if (result.error) {
+      const diagnostic = await diagnoseStartFormError(
+        bpmClient,
+        options.key,
+        extractClientErrorMessage(result.error)
+      );
+      exitWithClientError(spinner, "Failed to fetch start form info", result.error, diagnostic);
+    }
+    spinner.succeed("Start form info retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F680} Start Form Info\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch start form info", error);
+  }
+}
+async function getStartFormVariables(client, options) {
+  const spinner = createSpinner("Fetching start form variables...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getStartFormVariables(options.key);
+    if (result.error) {
+      const diagnostic = await diagnoseStartFormError(
+        bpmClient,
+        options.key,
+        extractClientErrorMessage(result.error)
+      );
+      exitWithClientError(spinner, "Failed to fetch start form variables", result.error, diagnostic);
+    }
+    spinner.succeed("Start form variables retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F680} Start Form Variables\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch start form variables", error);
+  }
+}
+async function getDeployedStartForm(client, options) {
+  const spinner = createSpinner("Fetching deployed start form...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getDeployedStartForm(options.key);
+    if (result.error) {
+      const diagnostic = await diagnoseStartFormError(
+        bpmClient,
+        options.key,
+        extractClientErrorMessage(result.error)
+      );
+      exitWithClientError(spinner, "Failed to fetch deployed start form", result.error, diagnostic);
+    }
+    spinner.succeed("Deployed start form retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F680} Deployed Start Form\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch deployed start form", error);
+  }
+}
+async function listHistoryTasks(client, options = {}) {
+  const spinner = createSpinner("Fetching history tasks...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryTaskQueryParams(options);
+    const result = await bpmClient.getHistoryTasks(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history tasks");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const tasks = result.data || [];
+    spinner.succeed(`Found ${tasks.length} history tasks`);
+    renderOutput(tasks, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} History Tasks\n"));
+        console.log(JSON.stringify(tasks, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history tasks", error);
+  }
+}
+async function getHistoryTaskCount(client, options = {}) {
+  const spinner = createSpinner("Fetching history task count...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryTaskQueryParams(options);
+    const result = await bpmClient.getHistoryTaskCount(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history task count");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("History task count retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.green(`History task count: ${result.data?.count ?? 0}`));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history task count", error);
+  }
+}
+async function listHistoryProcessInstances(client, options = {}) {
+  const spinner = createSpinner("Fetching history process instances...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryProcessInstanceQueryParams(options);
+    const result = await bpmClient.getHistoryProcessInstances(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history process instances");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const instances = result.data || [];
+    spinner.succeed(`Found ${instances.length} history process instances`);
+    renderOutput(instances, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} History Process Instances\n"));
+        console.log(JSON.stringify(instances, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history process instances", error);
+  }
+}
+async function getHistoryProcessInstanceCount(client, options = {}) {
+  const spinner = createSpinner("Fetching history process instance count...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryProcessInstanceQueryParams(options);
+    const result = await bpmClient.getHistoryProcessInstanceCount(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history process instance count");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("History process instance count retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.green(`History process instance count: ${result.data?.count ?? 0}`));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history process instance count", error);
+  }
+}
+async function getHistoryProcessInstance(client, options) {
+  const spinner = createSpinner("Fetching history process instance...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getHistoryProcessInstance(options.id);
+    if (result.error) {
+      spinner.fail("Failed to fetch history process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("History process instance retrieved");
+    renderOutput(result.data, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} History Process Instance\n"));
+        console.log(JSON.stringify(result.data, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history process instance", error);
+  }
+}
+async function listHistoryActivityInstances(client, options = {}) {
+  const spinner = createSpinner("Fetching history activity instances...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryActivityQueryParams(options);
+    const result = await bpmClient.getHistoryActivityInstances(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history activity instances");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const activities = result.data || [];
+    spinner.succeed(`Found ${activities.length} history activity instances`);
+    renderOutput(activities, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} History Activity Instances\n"));
+        console.log(JSON.stringify(activities, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history activity instances", error);
+  }
+}
+async function listHistoryVariableInstances(client, options = {}) {
+  const spinner = createSpinner("Fetching history variable instances...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildHistoryVariableQueryParams(options);
+    const result = await bpmClient.getHistoryVariableInstances(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch history variable instances");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const variables = result.data || [];
+    spinner.succeed(`Found ${variables.length} history variable instances`);
+    renderOutput(variables, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} History Variable Instances\n"));
+        console.log(JSON.stringify(variables, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch history variable instances", error);
+  }
+}
+async function listUserOperationLogs(client, options = {}) {
+  const spinner = createSpinner("Fetching user operation logs...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const params = buildUserOperationLogQueryParams(options);
+    const result = await bpmClient.getUserOperationLogs(params);
+    if (result.error) {
+      spinner.fail("Failed to fetch user operation logs");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const logs = result.data || [];
+    spinner.succeed(`Found ${logs.length} user operation logs`);
+    renderOutput(logs, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F4DA} User Operation Logs\n"));
+        console.log(JSON.stringify(logs, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch user operation logs", error);
+  }
+}
+async function deleteHistoryProcessInstance(client, options) {
+  const spinner = createSpinner(`Deleting history process instance: ${options.id}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.deleteHistoryProcessInstance(options.id);
+    if (result.error) {
+      spinner.fail("Failed to delete history process instance");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    spinner.succeed("History process instance deleted");
+    renderOutput(
+      {
+        id: options.id,
+        deleted: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`Deleted history process instance: ${options.id}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to delete history process instance", error);
+  }
+}
+async function listRoles(client, options = {}) {
+  const spinner = createSpinner("Fetching roles...", options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getRoles();
+    if (result.error) {
+      spinner.fail("Failed to fetch roles");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const roles = result.data || [];
+    spinner.succeed(`Found ${roles.length} roles`);
+    renderOutput(roles, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue("\n\u{1F465} Roles\n"));
+        console.log(JSON.stringify(roles, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch roles", error);
+  }
+}
+async function getUserRoles(client, options) {
+  const spinner = createSpinner(`Fetching roles for user: ${options.userId}...`, options.format);
+  try {
+    const bpmClient = client.bpm;
+    const result = await bpmClient.getUserRoles(options.userId);
+    if (result.error) {
+      spinner.fail("Failed to fetch user roles");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    const roles = result.data || [];
+    spinner.succeed(`Found ${roles.length} roles for user ${options.userId}`);
+    renderOutput(roles, {
+      format: options.format,
+      pretty: () => {
+        console.log(chalk3.blue(`
+\u{1F464} User Roles: ${options.userId}
+`));
+        console.log(JSON.stringify(roles, null, 2));
+      }
+    });
+  } catch (error) {
+    exitWithCommandError2(spinner, "Failed to fetch user roles", error);
+  }
+}
+function resolveInputSource3(input) {
+  if (!input.startsWith("@")) {
+    return input;
+  }
+  const filePath = input.slice(1);
+  if (!filePath) {
+    throw new Error("File path is required after '@'.");
+  }
+  return readFileSync(filePath, "utf8");
+}
+function parseJsonInput3(input, label) {
+  const source = resolveInputSource3(input).trim();
+  if (!source) {
+    throw new Error(`${label} is required.`);
+  }
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${label}: ${reason}`);
+  }
+}
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loadOptionalJsonObjectInput3(input, label) {
+  if (!input) {
+    return {};
+  }
+  const value = parseJsonInput3(input, label);
+  if (!isPlainObject4(value)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return value;
+}
+function loadOptionalJsonArrayInput(input, label) {
+  if (!input) {
+    return void 0;
+  }
+  const value = parseJsonInput3(input, label);
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be a JSON array.`);
   }
+  return value;
 }
-async function listWorkflows(client, options = {}) {
-  const spinner = createSpinner("Fetching workflows...", options.format);
-  try {
-    const workflowClient = client.workflow;
-    const result = await workflowClient.listWorkflows();
-    if (result.error) {
-      spinner.fail("Failed to fetch workflows");
-      console.error(chalk7.red(result.error.message));
-      process.exit(1);
+function exitWithCommandError3(spinner, failureMessage, error) {
+  spinner.fail(failureMessage);
+  const details = error instanceof Error ? error.message : String(error);
+  if (details) {
+    console.error(chalk3.red(details));
+  }
+  process.exit(1);
+}
+function buildWorkflowRunRequest(options) {
+  const request = loadOptionalJsonObjectInput3(options.request, "workflow request");
+  if (options.input) {
+    const inputs = parseJsonInput3(options.input, "workflow input");
+    if (!isPlainObject4(inputs)) {
+      throw new Error("workflow input must be a JSON object.");
     }
-    spinner.succeed(`Found ${result.data?.length || 0} workflows`);
-    const workflows = result.data || [];
-    renderOutput(workflows, {
-      format: options.format,
-      pretty: () => {
-        console.log(chalk7.blue("\n\u26A1 Workflows\n"));
-        for (const workflow of workflows) {
-          console.log(`  ${chalk7.green("\u2022")} ${chalk7.bold(workflow.code || workflow.id)}`);
-          console.log(`    ${chalk7.gray("Name:")} ${workflow.name || "N/A"}`);
-          console.log(`    ${chalk7.gray("Description:")} ${workflow.description || "N/A"}`);
-          console.log(`    ${chalk7.gray("Status:")} ${workflow.status || "N/A"}`);
-          console.log();
-        }
-      }
-    });
-  } catch (error) {
-    spinner.fail("Failed to fetch workflows");
-    throw error;
+    request.inputs = inputs;
+  }
+  if (options.responseMode) {
+    request.response_mode = options.responseMode;
+  }
+  if (options.user) {
+    request.user = options.user;
+  }
+  if (options.files) {
+    request.files = loadOptionalJsonArrayInput(options.files, "workflow files");
   }
+  if (options.traceId) {
+    request.trace_id = options.traceId;
+  }
+  return request;
 }
-async function executeWorkflow(client, options) {
-  const spinner = createSpinner(`Executing workflow: ${options.id}...`, options.format);
+async function runWorkflow(client, options) {
+  const spinner = createSpinner(`Running workflow: ${options.name}...`, options.format);
   try {
     const workflowClient = client.workflow;
-    const input = options.input ? JSON.parse(options.input) : {};
-    const result = await workflowClient.execute(options.id, {
-      input,
-      version: options.version
-    });
+    const request = buildWorkflowRunRequest(options);
+    const result = await workflowClient.run(options.name, request);
     if (result.error) {
-      spinner.fail("Failed to execute workflow");
-      console.error(chalk7.red(result.error.message));
+      spinner.fail("Failed to run workflow");
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
-    spinner.succeed("Workflow executed");
+    spinner.succeed("Workflow completed");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green("\nExecution Result:"));
+        console.log(chalk3.blue("\n\u26A1 Workflow Run\n"));
         console.log(JSON.stringify(result.data, null, 2));
       }
     });
   } catch (error) {
-    spinner.fail("Failed to execute workflow");
-    throw error;
+    exitWithCommandError3(spinner, "Failed to run workflow", error);
+  }
+}
+function exitWithCommandError4(spinner, failureMessage, error) {
+  spinner.fail(failureMessage);
+  const details = error instanceof Error ? error.message : String(error);
+  if (details) {
+    console.error(chalk3.red(details));
+  }
+  process.exit(1);
+}
+async function toBuffer(data) {
+  if (data instanceof Blob) {
+    return Buffer.from(await data.arrayBuffer());
+  }
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (typeof data === "string") {
+    return Buffer.from(data);
   }
+  if (typeof data === "object" && data !== null && "arrayBuffer" in data && typeof data.arrayBuffer === "function") {
+    const arrayBuffer = await data.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  throw new Error(`Unsupported download response type: ${Object.prototype.toString.call(data)}`);
 }
 async function uploadFile(client, options) {
   const spinner = createSpinner("Uploading file...", options.format);
@@ -1117,74 +2242,87 @@ async function uploadFile(client, options) {
       spinner.fail(`File not found: ${options.file}`);
       process.exit(1);
     }
-    const result = await s3Client.uploadFile(filePath, {
-      key: options.key,
-      bucket: options.bucket,
-      isPublic: options.public
-    });
+    const file = new File([readFileSync(filePath)], basename(filePath));
+    const result = await s3Client.upload(file);
     if (result.error) {
       spinner.fail("Upload failed");
-      console.error(chalk7.red(result.error.message));
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
     spinner.succeed("Upload complete");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.green("\nFile uploaded:"));
-        console.log(`  ${chalk7.bold("Key:")} ${result.data?.key}`);
-        console.log(`  ${chalk7.bold("URL:")} ${result.data?.url || "N/A"}`);
-        console.log(`  ${chalk7.bold("Bucket:")} ${result.data?.bucket || options.bucket || "default"}`);
+        console.log(chalk3.green("\nFile uploaded:"));
+        console.log(`  ${chalk3.bold("Key:")} ${result.data?.key}`);
+        console.log(`  ${chalk3.bold("URL:")} ${result.data?.url || "N/A"}`);
       }
     });
   } catch (error) {
-    spinner.fail("Upload failed");
-    throw error;
+    exitWithCommandError4(spinner, "Upload failed", error);
   }
 }
-async function listFiles(client, options) {
-  const spinner = createSpinner("Fetching files...", options.format);
+async function downloadFile(client, options) {
+  const spinner = createSpinner("Downloading file...", options.format);
   try {
     const s3Client = client.s3;
-    const result = await s3Client.listFiles({
-      bucket: options.bucket,
-      prefix: options.prefix,
-      page: options.page || 1,
-      pageSize: options.pageSize || 10
-    });
+    const result = await s3Client.download(options.key);
+    if (result.error) {
+      spinner.fail("Download failed");
+      console.error(chalk3.red(result.error.message));
+      process.exit(1);
+    }
+    if (!result.data) {
+      spinner.fail("Download failed");
+      console.error(chalk3.red("Empty file response."));
+      process.exit(1);
+    }
+    const outputPath = resolve(options.output);
+    const buffer = await toBuffer(result.data);
+    writeFileSync(outputPath, buffer);
+    spinner.succeed("Download complete");
+    renderOutput(
+      {
+        key: options.key,
+        output: outputPath,
+        downloaded: true
+      },
+      {
+        format: options.format,
+        pretty: () => {
+          console.log(chalk3.green(`
+File saved to: ${outputPath}`));
+        }
+      }
+    );
+  } catch (error) {
+    exitWithCommandError4(spinner, "Download failed", error);
+  }
+}
+async function getFileMetadata(client, options) {
+  const spinner = createSpinner("Fetching file metadata...", options.format);
+  try {
+    const s3Client = client.s3;
+    const result = await s3Client.getMetadata(options.key);
     if (result.error) {
-      spinner.fail("Failed to fetch files");
-      console.error(chalk7.red(result.error.message));
+      spinner.fail("Failed to fetch metadata");
+      console.error(chalk3.red(result.error.message));
       process.exit(1);
     }
-    spinner.succeed(`Found ${result.data?.total || 0} files`);
-    const files = result.data?.list || [];
+    spinner.succeed("Metadata retrieved");
     renderOutput(result.data, {
       format: options.format,
       pretty: () => {
-        console.log(chalk7.blue(`
-\u{1F4C1} Files${options.bucket ? ` in ${options.bucket}` : ""}
+        console.log(chalk3.blue(`
+\u{1F4C4} Metadata for ${options.key}
 `));
-        for (const file of files) {
-          console.log(`  ${chalk7.green("\u2022")} ${chalk7.bold(file.key)}`);
-          console.log(`    ${chalk7.gray("Size:")} ${formatBytes(file.size || 0)}`);
-          console.log(`    ${chalk7.gray("Modified:")} ${file.lastModified || "N/A"}`);
-          console.log();
-        }
+        console.log(JSON.stringify(result.data, null, 2));
       }
     });
   } catch (error) {
-    spinner.fail("Failed to fetch files");
-    throw error;
+    exitWithCommandError4(spinner, "Failed to fetch metadata", error);
   }
 }
-function formatBytes(bytes) {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-}
 
 // src/commands/openclaw.ts
 init_config();
@@ -1223,8 +2361,8 @@ async function initOpenClaw(options) {
     const existingConfig = getAppConfig(options.appCode);
     if (existingConfig && !options.force) {
       spinner.fail(`App already exists: ${options.appCode}`);
-      console.log(chalk7.yellow(`Use --force to reinitialize`));
-      console.log(chalk7.gray(`Current URL: ${existingConfig.baseURL}`));
+      console.log(chalk3.yellow(`Use --force to reinitialize`));
+      console.log(chalk3.gray(`Current URL: ${existingConfig.baseURL}`));
       process.exit(1);
     }
     addApp(options.appCode, {
@@ -1235,8 +2373,8 @@ async function initOpenClaw(options) {
     if (!openClawDetected) {
       spinner.succeed(`App initialized: ${options.appCode}`);
       if (pretty) {
-        console.log(chalk7.yellow("\n\u26A0\uFE0F  OpenClaw not detected, skipping skill download"));
-        console.log(chalk7.gray("   Install OpenClaw: npm install -g openclaw"));
+        console.log(chalk3.yellow("\n\u26A0\uFE0F  OpenClaw not detected, skipping skill download"));
+        console.log(chalk3.gray("   Install OpenClaw: npm install -g openclaw"));
       } else {
         renderOutput(
           {
@@ -1254,9 +2392,9 @@ async function initOpenClaw(options) {
     }
     spinner.succeed(`App initialized: ${options.appCode}`);
     if (pretty) {
-      console.log(chalk7.blue("\n\u{1F4CB} Configuration:\n"));
-      console.log(`  App Code: ${chalk7.green(options.appCode)}`);
-      console.log(`  Base URL: ${chalk7.gray(options.baseURL)}`);
+      console.log(chalk3.blue("\n\u{1F4CB} Configuration:\n"));
+      console.log(`  App Code: ${chalk3.green(options.appCode)}`);
+      console.log(`  Base URL: ${chalk3.gray(options.baseURL)}`);
       console.log();
     }
     spinner.start("Downloading skills...");
@@ -1328,16 +2466,16 @@ async function initOpenClaw(options) {
     };
     if (pretty) {
       console.log();
-      console.log(chalk7.green("\u2705 Initialization complete!"));
+      console.log(chalk3.green("\u2705 Initialization complete!"));
       console.log();
       console.log(`Next step: Login to your app`);
-      console.log(chalk7.gray(`  amaster login --app ${options.appCode}`));
+      console.log(chalk3.gray(`  amaster login --app ${options.appCode}`));
       console.log();
       if (apps.length > 1) {
-        console.log(chalk7.blue("Configured apps:"));
+        console.log(chalk3.blue("Configured apps:"));
         for (const app of apps) {
           const config = getAppConfig(app);
-          console.log(`  ${chalk7.gray("\u2022")} ${app} - ${config?.baseURL}`);
+          console.log(`  ${chalk3.gray("\u2022")} ${app} - ${config?.baseURL}`);
         }
         console.log();
       }
@@ -1446,40 +2584,45 @@ function resolveAppCode(optionsApp) {
   if (defaultApp) {
     return defaultApp;
   }
-  console.error(chalk7.red("\u274C No app specified."));
-  console.log(chalk7.yellow("Use one of:"));
-  console.log(chalk7.gray("  1. Add --app <app-code> to the command"));
-  console.log(chalk7.gray("  2. Set a default app: amaster use <app-code>"));
+  console.error(chalk3.red("\u274C No app specified."));
+  console.log(chalk3.yellow("Use one of:"));
+  console.log(chalk3.gray("  1. Add --app <app-code> to the command"));
+  console.log(chalk3.gray("  2. Set a default app: amaster use <app-code>"));
   process.exit(1);
 }
 function createAmasterClient(appCode) {
   const appConfig = getAppConfig(appCode);
   if (!appConfig) {
-    console.error(chalk7.red(`\u274C App not configured: ${appCode}`));
-    console.log(chalk7.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
+    console.error(chalk3.red(`\u274C App not configured: ${appCode}`));
+    console.log(chalk3.yellow(`Initialize it first: amaster init --app-code ${appCode} --url <url>`));
     process.exit(1);
   }
   const token = getAccessToken(appCode);
-  if (!token) {
-    console.error(chalk7.red(`\u274C Not authenticated for app: ${appCode}`));
-    console.log(chalk7.yellow(`Login first: amaster login --app ${appCode}`));
-    process.exit(1);
-  }
-  if (shouldRefreshToken(appCode)) {
-    console.error(chalk7.yellow("\u26A0\uFE0F  Session expiring soon. Please login again."));
+  if (token && shouldRefreshToken(appCode)) {
+    console.error(chalk3.yellow("\u26A0\uFE0F  Session expiring soon. Please login again."));
   }
   const client = createClient({
     baseURL: appConfig.baseURL,
-    headers: {
-      Authorization: `Bearer ${token}`
-    },
+    ...token ? {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    } : {},
     onUnauthorized: () => {
-      console.error(chalk7.red("\n\u274C Session expired. Please login again."));
-      console.error(chalk7.yellow(`Run: amaster login --app ${appCode}`));
+      if (token) {
+        console.error(chalk3.red("\n\u274C Session expired. Please login again."));
+        console.error(chalk3.yellow(`Run: amaster login --app ${appCode}`));
+      } else {
+        console.error(chalk3.red(`
+\u274C Authentication required for app: ${appCode}`));
+        console.error(chalk3.yellow(`Run: amaster login --app ${appCode}`));
+      }
       process.exit(1);
     }
   });
-  client.setAccessToken(token);
+  if (token) {
+    client.setAccessToken(token);
+  }
   return client;
 }
 var program = new Command();
@@ -1499,17 +2642,17 @@ program.command("apps").description("List all configured apps").addOption(create
   renderOutput(appSummaries, {
     format: options.format,
     pretty: () => {
-      console.log(chalk7.blue("\n\u{1F4F1} Configured Apps\n"));
+      console.log(chalk3.blue("\n\u{1F4F1} Configured Apps\n"));
       if (appSummaries.length === 0) {
-        console.log(chalk7.gray("  No apps configured"));
-        console.log(chalk7.gray("  Run: amaster init --app-code <code> --url <url>"));
+        console.log(chalk3.gray("  No apps configured"));
+        console.log(chalk3.gray("  Run: amaster init --app-code <code> --url <url>"));
       } else {
         for (const app of appSummaries) {
-          const prefix = app.current ? chalk7.green("\u2192 ") : "  ";
-          console.log(`${prefix}${chalk7.bold(app.appCode)}${app.current ? chalk7.green(" (current)") : ""}`);
-          console.log(`     ${chalk7.gray(app.baseURL || "No URL")}`);
+          const prefix = app.current ? chalk3.green("\u2192 ") : "  ";
+          console.log(`${prefix}${chalk3.bold(app.appCode)}${app.current ? chalk3.green(" (current)") : ""}`);
+          console.log(`     ${chalk3.gray(app.baseURL || "No URL")}`);
           console.log(
-            `     ${app.authenticated ? chalk7.green("\u25CF Authenticated") : chalk7.yellow("\u25CB Not authenticated")}`
+            `     ${app.authenticated ? chalk3.green("\u25CF Authenticated") : chalk3.yellow("\u25CB Not authenticated")}`
           );
           console.log();
         }
@@ -1528,12 +2671,12 @@ program.command("use <app-code>").description("Set the default app for subsequen
       {
         format: options.format,
         pretty: () => {
-          console.log(chalk7.green(`\u2705 Now using app: ${appCode}`));
+          console.log(chalk3.green(`\u2705 Now using app: ${appCode}`));
         }
       }
     );
   } else {
-    console.error(chalk7.red(`\u274C App not found: ${appCode}`));
+    console.error(chalk3.red(`\u274C App not found: ${appCode}`));
     process.exit(1);
   }
 });
@@ -1565,13 +2708,13 @@ program.command("whoami").description("Show current user information").option("-
   await getMe(() => createAmasterClient(appCode), { format: options.format });
 });
 var entityCmd = program.command("entity").description("Manage entities");
-entityCmd.command("list <namespace> <entity>").description("List entities").option("--app <app-code>", "App code (uses default if not specified)").option("--page <page>", "Page number", "1").option("--page-size <size>", "Page size", "10").option("-f, --fields <fields>", "Comma-separated fields to return").option("-r, --relations <relations>", "Comma-separated relations to load").option("-k, --keyword <keyword>", "Keyword to search").option("--keyword-fields <fields>", "Comma-separated fields for keyword search").option("--order-by <field>", "Field to sort by").addOption(new Option("--order-dir <dir>", "Sort direction").choices(["asc", "desc"])).option("--orders <orders>", "Multi-order expression, e.g. created_at:desc,name:asc").option("--filter <json>", "Advanced __filter JSON or @file").option("--limit <limit>", "Limit number of records").option("--offset <offset>", "Offset number of records").option("-q, --query <json>", "Additional EntityQueryParams as JSON or @file").addOption(createFormatOption()).action(async (namespace, entityName, options) => {
+entityCmd.command("list <namespace> <entity>").description("List entities").option("--app <app-code>", "App code (uses default if not specified)").option("--page <page>", "Page number").option("--page-size <size>", "Page size").option("-f, --fields <fields>", "Comma-separated fields to return").option("-r, --relations <relations>", "Comma-separated relations to load").option("-k, --keyword <keyword>", "Keyword to search").option("--keyword-fields <fields>", "Comma-separated fields for keyword search").option("--order-by <field>", "Field to sort by").addOption(new Option("--order-dir <dir>", "Sort direction").choices(["asc", "desc"])).option("--orders <orders>", "Multi-order expression, e.g. created_at:desc,name:asc").option("--filter <json>", "Advanced __filter JSON or @file").option("--limit <limit>", "Limit number of records").option("--offset <offset>", "Offset number of records").option("-q, --query <json>", "Additional EntityQueryParams as JSON or @file").addOption(createFormatOption()).action(async (namespace, entityName, options) => {
   const appCode = resolveAppCode(options.app);
   await listEntities(createAmasterClient(appCode), {
     namespace,
     entity: entityName,
-    page: parseInt(options.page),
-    pageSize: parseInt(options.pageSize),
+    page: options.page ? parseInt(options.page) : void 0,
+    pageSize: options.pageSize ? parseInt(options.pageSize) : void 0,
     fields: options.fields,
     relations: options.relations,
     keyword: options.keyword,
@@ -1651,11 +2794,28 @@ entityCmd.command("bulk-delete <namespace> <entity>").description("Bulk delete e
   });
 });
 var bpmCmd = program.command("bpm").description("Manage BPM processes and tasks");
-bpmCmd.command("processes").description("List process definitions").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (options) => {
+bpmCmd.command("processes").description("List process definitions").option("--app <app-code>", "App code (uses default if not specified)").option("--key <key>", "Filter by process definition key").option("--name <name>", "Filter by process definition name").option("--latest-version", "Only return latest version").option("--active", "Only return active process definitions").option("--suspended", "Only return suspended process definitions").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional ProcessDefinitionQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listProcesses(createAmasterClient(appCode), {
+    key: options.key,
+    name: options.name,
+    latestVersion: options.latestVersion,
+    active: options.active,
+    suspended: options.suspended,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("xml <key>").description("Get BPMN XML for a process definition key").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, options) => {
   const appCode = resolveAppCode(options.app);
-  await listProcesses(createAmasterClient(appCode), { format: options.format });
+  await getProcessXml(createAmasterClient(appCode), {
+    key,
+    format: options.format
+  });
 });
-bpmCmd.command("start <key>").description("Start a process instance").option("--app <app-code>", "App code (uses default if not specified)").option("-v, --variables <json>", "Process variables as JSON").addOption(createFormatOption()).action(async (key, options) => {
+bpmCmd.command("start <key>").description("Start a process instance").option("--app <app-code>", "App code (uses default if not specified)").option("-v, --variables <json>", "Process variables as JSON or @file").addOption(createFormatOption()).action(async (key, options) => {
   const appCode = resolveAppCode(options.app);
   await startProcess(createAmasterClient(appCode), {
     key,
@@ -1663,14 +2823,127 @@ bpmCmd.command("start <key>").description("Start a process instance").option("--
     format: options.format
   });
 });
-bpmCmd.command("tasks").description("List tasks").option("--app <app-code>", "App code (uses default if not specified)").option("-a, --assignee <assignee>", "Filter by assignee").addOption(createFormatOption()).action(async (options) => {
+bpmCmd.command("instances").description("List process instances").option("--app <app-code>", "App code (uses default if not specified)").option("--process-definition-key <key>", "Filter by process definition key").option("--active", "Only return active instances").option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("-q, --query <json>", "Additional ProcessInstanceQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listProcessInstances(createAmasterClient(appCode), {
+    processDefinitionKey: options.processDefinitionKey,
+    active: options.active,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("instance <id>").description("Get a process instance by ID").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getProcessInstance(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("instance-tree <id>").description("Get the activity instance tree for a process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getActivityInstanceTree(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("active-activities <id>").description("Get active activities for a process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getActiveActivities(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("runtime-variables <id>").description("Get runtime variables for a process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getRuntimeVariables(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("variables <id>").description("Get historic variables for a process instance").option("--app <app-code>", "App code (uses default if not specified)").option("--name <name>", "Filter by variable name").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getProcessVariables(createAmasterClient(appCode), {
+    id,
+    name: options.name,
+    format: options.format
+  });
+});
+bpmCmd.command("delete-instance <id>").description("Delete a process instance").option("--app <app-code>", "App code (uses default if not specified)").option("--skip-custom-listeners", "Skip custom listeners during deletion").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await deleteProcessInstance(createAmasterClient(appCode), {
+    id,
+    skipCustomListeners: options.skipCustomListeners,
+    format: options.format
+  });
+});
+bpmCmd.command("suspend-instance <id>").description("Suspend a process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await suspendProcessInstance(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("activate-instance <id>").description("Activate a suspended process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await activateProcessInstance(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("modify-instance <id>").description("Modify a process instance").option("--app <app-code>", "App code (uses default if not specified)").option("-m, --modification <json>", "ProcessInstanceModification JSON or @file").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await modifyProcessInstance(createAmasterClient(appCode), {
+    id,
+    modification: options.modification,
+    format: options.format
+  });
+});
+bpmCmd.command("tasks").description("List tasks").option("--app <app-code>", "App code (uses default if not specified)").option("-a, --assignee <assignee>", "Filter by assignee").option("--process-instance-id <id>", "Filter by process instance ID").option("--candidate-user <user>", "Filter by candidate user").option("--candidate-group <group>", "Filter by candidate group").option("--name <name>", "Filter by exact task name").option("--name-like <name>", "Filter by fuzzy task name").option("--task-definition-key <key>", "Filter by task definition key").option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional TaskQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
   const appCode = resolveAppCode(options.app);
   await listTasks(createAmasterClient(appCode), {
+    processInstanceId: options.processInstanceId,
+    assignee: options.assignee,
+    candidateUser: options.candidateUser,
+    candidateGroup: options.candidateGroup,
+    name: options.name,
+    nameLike: options.nameLike,
+    taskDefinitionKey: options.taskDefinitionKey,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("task <id>").description("Get a task by ID").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getTask(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("task-count").description("Get task count").option("--app <app-code>", "App code (uses default if not specified)").option("-a, --assignee <assignee>", "Filter by assignee").option("--process-instance-id <id>", "Filter by process instance ID").option("--candidate-user <user>", "Filter by candidate user").option("--candidate-group <group>", "Filter by candidate group").option("--name <name>", "Filter by exact task name").option("--name-like <name>", "Filter by fuzzy task name").option("--task-definition-key <key>", "Filter by task definition key").option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional TaskQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await getTaskCount(createAmasterClient(appCode), {
+    processInstanceId: options.processInstanceId,
     assignee: options.assignee,
+    candidateUser: options.candidateUser,
+    candidateGroup: options.candidateGroup,
+    name: options.name,
+    nameLike: options.nameLike,
+    taskDefinitionKey: options.taskDefinitionKey,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
     format: options.format
   });
 });
-bpmCmd.command("complete <id>").description("Complete a task").option("--app <app-code>", "App code (uses default if not specified)").option("-v, --variables <json>", "Task variables as JSON").addOption(createFormatOption()).action(async (id, options) => {
+bpmCmd.command("complete <id>").description("Complete a task").option("--app <app-code>", "App code (uses default if not specified)").option("-v, --variables <json>", "Task variables as JSON or @file").addOption(createFormatOption()).action(async (id, options) => {
   const appCode = resolveAppCode(options.app);
   await completeTask(createAmasterClient(appCode), {
     id,
@@ -1678,33 +2951,236 @@ bpmCmd.command("complete <id>").description("Complete a task").option("--app <ap
     format: options.format
   });
 });
-var workflowCmd = program.command("workflow").description("Manage workflows");
-workflowCmd.command("list").description("List workflows").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (options) => {
+bpmCmd.command("delegate <id>").description("Delegate a task to another user").option("--app <app-code>", "App code (uses default if not specified)").requiredOption("--user-id <userId>", "Delegate target user ID").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await delegateTask(createAmasterClient(appCode), {
+    id,
+    userId: options.userId,
+    format: options.format
+  });
+});
+bpmCmd.command("task-form <id>").description("Get task form metadata").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
   const appCode = resolveAppCode(options.app);
-  await listWorkflows(createAmasterClient(appCode), { format: options.format });
+  await getTaskForm(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
 });
-workflowCmd.command("execute <id>").description("Execute a workflow").option("--app <app-code>", "App code (uses default if not specified)").option("-i, --input <json>", "Workflow input as JSON").addOption(createFormatOption()).action(async (id, options) => {
+bpmCmd.command("task-form-schema <id>").description("Get task form schema").option("--app <app-code>", "App code (uses default if not specified)").option("--redirect <url>", "Optional redirect URL").addOption(createFormatOption()).action(async (id, options) => {
   const appCode = resolveAppCode(options.app);
-  await executeWorkflow(createAmasterClient(appCode), {
+  await getTaskFormSchema(createAmasterClient(appCode), {
     id,
-    input: options.input,
+    redirect: options.redirect,
     format: options.format
   });
 });
-var s3Cmd = program.command("s3").description("Manage S3 files");
-s3Cmd.command("list").description("List files").option("--app <app-code>", "App code (uses default if not specified)").option("-b, --bucket <bucket>", "Bucket name").addOption(createFormatOption()).action(async (options) => {
+bpmCmd.command("task-form-variables <id>").description("Get task form variables").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getTaskFormVariables(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("task-rendered-form <id>").description("Get rendered task form HTML").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getTaskRenderedForm(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("task-deployed-form <id>").description("Get deployed task form definition").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getTaskDeployedForm(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("start-form <key>").description("Get start form info for a process definition key").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getStartFormInfo(createAmasterClient(appCode), {
+    key,
+    format: options.format
+  });
+});
+bpmCmd.command("start-form-variables <key>").description("Get start form variables for a process definition key").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getStartFormVariables(createAmasterClient(appCode), {
+    key,
+    format: options.format
+  });
+});
+bpmCmd.command("history-tasks").description("List history tasks").option("--app <app-code>", "App code (uses default if not specified)").option("--task-assignee <assignee>", "Filter by historical task assignee").option("--process-instance-id <id>", "Filter by process instance ID").option("--finished", "Only return finished history tasks").option("--unfinished", "Only return unfinished history tasks").addOption(new Option("--scope <scope>", "History task scope").choices(["handled"])).option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional HistoryTaskQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listHistoryTasks(createAmasterClient(appCode), {
+    taskAssignee: options.taskAssignee,
+    processInstanceId: options.processInstanceId,
+    finished: options.finished,
+    unfinished: options.unfinished,
+    scope: options.scope,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("history-task-count").description("Get history task count").option("--app <app-code>", "App code (uses default if not specified)").option("--task-assignee <assignee>", "Filter by historical task assignee").option("--process-instance-id <id>", "Filter by process instance ID").option("--finished", "Only count finished history tasks").option("--unfinished", "Only count unfinished history tasks").addOption(new Option("--scope <scope>", "History task scope").choices(["handled"])).option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional HistoryTaskQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await getHistoryTaskCount(createAmasterClient(appCode), {
+    taskAssignee: options.taskAssignee,
+    processInstanceId: options.processInstanceId,
+    finished: options.finished,
+    unfinished: options.unfinished,
+    scope: options.scope,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("history-instances").description("List history process instances").option("--app <app-code>", "App code (uses default if not specified)").option("--started-by <userId>", "Filter by starter user ID").option("--process-definition-key <key>", "Filter by process definition key").option("--finished", "Only return finished history instances").option("--unfinished", "Only return unfinished history instances").addOption(new Option("--scope <scope>", "History process scope").choices(["initiated"])).option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("-q, --query <json>", "Additional HistoryProcessInstanceQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listHistoryProcessInstances(createAmasterClient(appCode), {
+    startedBy: options.startedBy,
+    processDefinitionKey: options.processDefinitionKey,
+    finished: options.finished,
+    unfinished: options.unfinished,
+    scope: options.scope,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("history-instance-count").description("Get history process instance count").option("--app <app-code>", "App code (uses default if not specified)").option("--started-by <userId>", "Filter by starter user ID").option("--process-definition-key <key>", "Filter by process definition key").option("--finished", "Only count finished history instances").option("--unfinished", "Only count unfinished history instances").addOption(new Option("--scope <scope>", "History process scope").choices(["initiated"])).option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("-q, --query <json>", "Additional HistoryProcessInstanceQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await getHistoryProcessInstanceCount(createAmasterClient(appCode), {
+    startedBy: options.startedBy,
+    processDefinitionKey: options.processDefinitionKey,
+    finished: options.finished,
+    unfinished: options.unfinished,
+    scope: options.scope,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("history-instance <id>").description("Get a history process instance by ID").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getHistoryProcessInstance(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("history-activities").description("List history activity instances").option("--app <app-code>", "App code (uses default if not specified)").option("--process-instance-id <id>", "Filter by process instance ID").option("--activity-id <activityId>", "Filter by BPMN activity ID").option("--activity-type <activityType>", "Filter by activity type").option("--finished", "Only return finished history activity instances").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("-q, --query <json>", "Additional HistoryActivityQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listHistoryActivityInstances(createAmasterClient(appCode), {
+    processInstanceId: options.processInstanceId,
+    activityId: options.activityId,
+    activityType: options.activityType,
+    finished: options.finished,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("history-variables").description("List history variable instances").option("--app <app-code>", "App code (uses default if not specified)").option("--process-instance-id <id>", "Filter by process instance ID").option("--variable-name <name>", "Filter by variable name").option("--deserialize-values", "Deserialize complex variable values").option("-q, --query <json>", "Additional HistoryVariableQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listHistoryVariableInstances(createAmasterClient(appCode), {
+    processInstanceId: options.processInstanceId,
+    variableName: options.variableName,
+    deserializeValues: options.deserializeValues,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("user-operations").description("List user operation logs").option("--app <app-code>", "App code (uses default if not specified)").option("--process-instance-id <id>", "Filter by process instance ID").option("--task-id <id>", "Filter by task ID").option("--user-id <userId>", "Filter by user ID").option("--operation-type <type>", "Filter by operation type").option("--sort-by <field>", "Sort field").addOption(new Option("--sort-order <order>", "Sort order").choices(["asc", "desc"])).option("--first-result <n>", "Pagination offset").option("--max-results <n>", "Maximum number of results").option("-q, --query <json>", "Additional UserOperationLogQueryParams as JSON or @file").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listUserOperationLogs(createAmasterClient(appCode), {
+    processInstanceId: options.processInstanceId,
+    taskId: options.taskId,
+    userId: options.userId,
+    operationType: options.operationType,
+    sortBy: options.sortBy,
+    sortOrder: options.sortOrder,
+    firstResult: options.firstResult ? parseInt(options.firstResult) : void 0,
+    maxResults: options.maxResults ? parseInt(options.maxResults) : void 0,
+    query: options.query,
+    format: options.format
+  });
+});
+bpmCmd.command("delete-history-instance <id>").description("Delete a history process instance").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (id, options) => {
+  const appCode = resolveAppCode(options.app);
+  await deleteHistoryProcessInstance(createAmasterClient(appCode), {
+    id,
+    format: options.format
+  });
+});
+bpmCmd.command("roles").description("List runtime roles").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (options) => {
+  const appCode = resolveAppCode(options.app);
+  await listRoles(createAmasterClient(appCode), {
+    format: options.format
+  });
+});
+bpmCmd.command("user-roles <userId>").description("List roles assigned to a user").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (userId, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getUserRoles(createAmasterClient(appCode), {
+    userId,
+    format: options.format
+  });
+});
+bpmCmd.command("start-form-deployed <key>").description("Get deployed start form definition for a process definition key").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getDeployedStartForm(createAmasterClient(appCode), {
+    key,
+    format: options.format
+  });
+});
+var workflowCmd = program.command("workflow").description("Run workflows");
+workflowCmd.command("run <name>").alias("execute").description("Run a workflow").option("--app <app-code>", "App code (uses default if not specified)").option("-i, --input <json>", "Workflow inputs object as JSON or @file").option("-r, --request <json>", "Full WorkflowRunRequest as JSON or @file").addOption(
+  new Option("--response-mode <mode>", "Workflow response mode").choices(["blocking", "streaming"])
+).option("--user <user>", "Workflow user identifier").option("--files <json>", "Workflow files array as JSON or @file").option("--trace-id <traceId>", "Workflow trace ID").addOption(createFormatOption()).action(async (name, options) => {
   const appCode = resolveAppCode(options.app);
-  await listFiles(createAmasterClient(appCode), {
-    bucket: options.bucket,
+  await runWorkflow(createAmasterClient(appCode), {
+    name,
+    input: options.input,
+    request: options.request,
+    responseMode: options.responseMode,
+    user: options.user,
+    files: options.files,
+    traceId: options.traceId,
     format: options.format
   });
 });
-s3Cmd.command("upload <file>").description("Upload a file").option("--app <app-code>", "App code (uses default if not specified)").option("-b, --bucket <bucket>", "Bucket name").option("-k, --key <key>", "Object key").addOption(createFormatOption()).action(async (file, options) => {
+var s3Cmd = program.command("s3").description("Manage S3 files");
+s3Cmd.command("upload <file>").description("Upload a file").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (file, options) => {
   const appCode = resolveAppCode(options.app);
   await uploadFile(createAmasterClient(appCode), {
     file,
-    bucket: options.bucket,
-    key: options.key,
+    format: options.format
+  });
+});
+s3Cmd.command("download <key> <output>").description("Download a file to a local path").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, output, options) => {
+  const appCode = resolveAppCode(options.app);
+  await downloadFile(createAmasterClient(appCode), {
+    key,
+    output,
+    format: options.format
+  });
+});
+s3Cmd.command("metadata <key>").description("Get file metadata").option("--app <app-code>", "App code (uses default if not specified)").addOption(createFormatOption()).action(async (key, options) => {
+  const appCode = resolveAppCode(options.app);
+  await getFileMetadata(createAmasterClient(appCode), {
+    key,
     format: options.format
   });
 });