camunda-cli 0.4.2 → 0.5.0

package/PANDUAN.md

@@ -152,6 +152,20 @@ camunda cancel --key Process_X -y -r "bersih-bersih" # tanpa konfirmasi
 
 Menguji meninggalkan banyak instance menggantung. Tanpa `-y` akan diminta konfirmasi.
 
+Untuk mengosongkan inbox satu penguji di AlurKerja sekaligus, tanpa peduli prosesnya:
+
+```bash
+camunda remove dev-anla me@anla.my.id --dry-run   # lihat dulu apa yang akan dihapus
+camunda remove dev-anla me@anla.my.id             # hapus, diminta mengetik jumlah instance
+```
+
+Perintah ini menghapus setiap instance yang punya task terbuka milik email itu di tenant
+`<Nama> (TEST)` workspace tersebut. Workspace boleh slug atau nama (`dev-anla`, `Plan Route`),
+atau id tenant TEST kalau namanya ambigu (`hospital (TEST)` dan `Hospital (TEST)`) atau slug-nya
+tidak mengikuti nama (`new-workspace` berjalan di `Telco (TEST)`). Id tenant LIVE ditolak.
+Menghapus instance anak call activity ikut menghentikan induknya, jadi seluruh request berakhir,
+termasuk task orang lain di request yang sama.
+
 ---
 
 ## Kasus 3: instance macet atau gagal

package/README.md

@@ -132,7 +132,7 @@ sentence you need is at the bottom, so that is what gets printed first.
 ```
 Session      login  logout  whoami
 Models       definitions  inspect  lint  xml  stats
-Instances    instances  instance  start  cancel  vars  set-var
+Instances    instances  instance  start  cancel  remove  vars  set-var
 Diagnosis    diagnose  trace  incidents  jobs  stacktrace
 Tasks        tasks  task  complete  claim
 Deployment   deployments  deploy  undeploy
@@ -173,6 +173,12 @@ Instance 3435051 finished in 8.0s.
 **Cleaning up after a test run.** `cancel --key <key>` terminates every running instance of
 a process in one go, which matters because testing a model leaves a trail of them behind.
 
+`remove <workspace> <email>` clears one tester's inbox on an AlurKerja engine instead: it
+deletes every instance holding an open task assigned to that email in the workspace's
+`<Name> (TEST)` tenant. The workspace is a slug or name (`dev-anla`, `Plan Route`) or a Test
+tenant id; a Live tenant id is refused. `--dry-run` lists what would go. Deleting a called
+child instance also terminates its parent, so the whole request ends, not only that task.
+
 **Variable types matter.** `--var n=300` sends a string, and `"300" > 200` is a string
 comparison. Use `--var n=300:Integer` where a gateway compares numerically, or `name:=<json>`
 for structured values.

package/bin/camunda.js

@@ -4,7 +4,7 @@ import { configureOutput, isJsonMode } from '../src/output.js';
 import { unwrapError, explain } from '../src/errors.js';
 import { loginCommand, logoutCommand, whoamiCommand } from '../src/commands/session.js';
 import { definitionsCommand, inspectCommand, lintCommand, xmlCommand, statsCommand } from '../src/commands/definitions.js';
-import { instancesCommand, instanceCommand, startCommand, cancelCommand, varsCommand } from '../src/commands/instances.js';
+import { instancesCommand, instanceCommand, startCommand, cancelCommand, removeCommand, varsCommand } from '../src/commands/instances.js';
 import { diagnoseCommand, incidentsCommand, jobsCommand, stacktraceCommand, traceCommand } from '../src/commands/diagnose.js';
 import { tasksCommand, taskCommand, completeCommand, claimCommand } from '../src/commands/tasks.js';
 import { deploymentsCommand, deployCommand, undeployCommand } from '../src/commands/deploy.js';
@@ -24,7 +24,7 @@ program
       'Start with "camunda inspect <key>" to read a deployed model, and\n' +
       '"camunda diagnose <instanceId>" when an instance misbehaves.'
   )
-  .version('0.4.2')
+  .version('0.5.0')
   .option('--json', 'print the raw API payload instead of a formatted view')
   .option('--no-color', 'never emit colour, even on a terminal')
   .showHelpAfterError()
@@ -130,6 +130,13 @@ withTenant(
     .option('-y, --yes', 'skip the confirmation prompt')
 ).action(cancelCommand);
 
+program
+  .command('remove <workspace> <assignee>')
+  .description("Delete every instance holding an open task for <assignee> in a workspace's TEST tenant (workspace slug, name, or TEST tenant id)")
+  .option('--dry-run', 'list what would be deleted and stop')
+  .option('-y, --yes', 'skip the confirmation prompt')
+  .action(removeCommand);
+
 program
   .command('vars <instanceId>')
   .description('Variables on an instance, or every write to them with --history')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camunda-cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Command-line client for self-hosted Camunda 7: inspect and lint deployed BPMN models, and diagnose why an instance is stuck",
   "license": "MIT",
   "type": "module",

package/src/client.js

@@ -159,9 +159,9 @@ export class Client {
   activityInstanceTree(id) {
     return this.get(`/process-instance/${id}/activity-instances`);
   }
-  deleteProcessInstance(id, { reason, skipCustomListeners = true, skipIoMappings = true } = {}) {
+  deleteProcessInstance(id, { reason, skipCustomListeners = true, skipIoMappings = true, skipSubprocesses } = {}) {
     return this.request('DELETE', `/process-instance/${id}`, {
-      query: { skipCustomListeners, skipIoMappings, deleteReason: reason },
+      query: { skipCustomListeners, skipIoMappings, skipSubprocesses, deleteReason: reason },
     });
   }
   suspendProcessInstance(id, suspended) {

package/src/commands/instances.js

@@ -187,6 +187,102 @@ export async function cancelCommand(id, options) {
   if (failures.length > 0) process.exitCode = 1;
 }
 
+// AlurKerja runs each workspace on two tenants, "<Name>" for Live and "<Name> (TEST)" for
+// Test. Clearing a tester's inbox only ever touches the Test one, so the workspace is
+// resolved to its "(TEST)" tenant and a Live tenant id is refused outright.
+const TENANT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TEST_SUFFIX = /\s*\(TEST\)\s*$/i;
+const workspaceSlug = (name) =>
+  String(name ?? '')
+    .replace(TEST_SUFFIX, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+async function resolveTestTenant(client, workspace) {
+  if (TENANT_ID.test(workspace)) {
+    const [tenant] = await client.tenants({ id: workspace });
+    if (!tenant) throw new Error(`No tenant with id ${workspace}.`);
+    if (!TEST_SUFFIX.test(tenant.name ?? '')) {
+      throw new Error(`${workspace} is "${tenant.name}", a Live tenant. remove only clears "(TEST)" tenants.`);
+    }
+    return tenant;
+  }
+
+  const wanted = workspaceSlug(workspace);
+  const all = await client.tenants({ maxResults: 1000 });
+  const matches = all.filter((t) => TEST_SUFFIX.test(t.name ?? '') && workspaceSlug(t.name) === wanted);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const list = matches.map((t) => `  ${t.id}  ${t.name}`).join('\n');
+    throw new Error(`"${workspace}" matches ${matches.length} Test tenants. Pass the tenant id instead:\n${list}`);
+  }
+  // The engine only knows tenant names, and a workspace slug does not always follow its
+  // name (the "new-workspace" slug runs on "Telco (TEST)").
+  throw new Error(`No Test tenant named like "${workspace}". Find it with: camunda tenants -s <name>, then pass its id.`);
+}
+
+// Clears every open task assigned to one person in a workspace's Test tenant by deleting
+// the instance each task belongs to. Repeated test runs fill a tester's inbox faster than
+// cancelling them one request at a time in the App can empty it.
+export async function removeCommand(workspace, assignee, options) {
+  const client = new Client(requireConfig());
+  const tenant = await resolveTestTenant(client, workspace);
+
+  const tasks = await client.tasks({ tenantIdIn: tenant.id, assignee });
+  const instanceIds = [...new Set(tasks.map((t) => t.processInstanceId).filter(Boolean))].sort();
+
+  if (out.isJsonMode() && options.dryRun) return out.json({ tenant, assignee, tasks, instanceIds });
+
+  out.heading(`${tenant.name}  ${tenant.id}`);
+  out.kv([['assignee', assignee]]);
+  if (tasks.length === 0) return out.note(`\nNo open tasks assigned to ${assignee}.`);
+
+  const perName = new Map();
+  for (const t of tasks) perName.set(t.name ?? '(unnamed)', (perName.get(t.name ?? '(unnamed)') ?? 0) + 1);
+  out.line(`\n${tasks.length} open task(s) across ${instanceIds.length} instance(s)`);
+  out.table(
+    ['TASKS', 'NAME'],
+    [...perName].sort((a, b) => b[1] - a[1]).map(([name, count]) => [String(count), out.truncate(name, 60)])
+  );
+
+  if (options.dryRun) return out.note('\nDry run, nothing deleted.');
+
+  if (!options.yes) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const expect = String(instanceIds.length);
+    const answer = await rl.question(
+      `\nDeleting ${expect} instance(s) cannot be undone. Type "${expect}" to confirm: `
+    );
+    rl.close();
+    if (answer.trim() !== expect) return out.note('Aborted, that did not match.');
+  }
+
+  let removed = 0;
+  let gone = 0;
+  const failures = [];
+  for (const id of instanceIds) {
+    try {
+      await client.deleteProcessInstance(id, { skipSubprocesses: true });
+      removed++;
+    } catch (err) {
+      // Two tasks can share an instance with a parent that was deleted first.
+      if (err.status === 404) gone++;
+      else failures.push(`${id}: ${err.body?.message || err.message}`);
+    }
+  }
+  const left = await client.tasks({ tenantIdIn: tenant.id, assignee });
+
+  if (out.isJsonMode()) {
+    return out.json({ tenant, assignee, removed, alreadyGone: gone, failures, remainingTasks: left.length });
+  }
+  out.line(`\nDeleted ${removed} instance(s).${gone ? ` ${gone} were already gone.` : ''}`);
+  for (const f of failures) out.problem(`  ${f}`);
+  if (left.length > 0) out.warn(`${left.length} task(s) still assigned to ${assignee}.`);
+  else out.note(`No open tasks left for ${assignee}.`);
+  if (failures.length > 0) process.exitCode = 1;
+}
+
 export async function varsCommand(id, options) {
   const client = new Client(requireConfig());
 

package/src/commands/ops.js

@@ -65,7 +65,23 @@ export async function messageCommand(name, options) {
   if (options.businessKey) body.businessKey = options.businessKey;
   if (options.all) body.all = true;
 
-  const result = await client.correlateMessage(body);
+  // Camunda answers a message that matches nothing with an exception rather than an empty
+  // result, so the ordinary case of getting the name or business key wrong arrives as a
+  // Java class name unless it is caught here.
+  let result;
+  try {
+    result = await client.correlateMessage(body);
+  } catch (err) {
+    const raw = err.body?.message || err.message || '';
+    if (/MismatchingMessageCorrelation|No process definition or execution matches/.test(raw)) {
+      out.warn(`Nothing is waiting for a message called "${name}"${options.instance ? ` on instance ${options.instance}` : ''}${options.businessKey ? ` with business key ${options.businessKey}` : ''}.`);
+      out.note('camunda subscriptions   shows what is currently waiting, and under which name.');
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+
   if (out.isJsonMode()) return out.json(result);
 
   if (!result || result.length === 0) {