camunda-cli 0.4.3 → 0.6.0

package/PANDUAN.md

@@ -152,6 +152,24 @@ 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
+camunda remove dev-anla me@anla.my.id --live      # tenant LIVE: peringatan, lalu ketik nama tenant
+```
+
+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 kecuali
+memakai `--live`. Dengan `--live`, setelah daftar task muncul peringatan bahwa ini tenant LIVE (request
+sungguhan, bukan data uji) dan nama tenant harus diketik persis untuk melanjutkan; `-y` tidak
+melewati konfirmasi ini.
+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,14 @@ 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. `--live` clears the
+workspace's Live tenant instead: after the list it prints a warning and asks for the tenant name
+to be typed, a prompt `--yes` does not skip. 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.3')
+  .version('0.6.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,14 @@ 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, or its LIVE tenant with --live (workspace slug, name, or tenant id)")
+  .option('--live', 'clear the LIVE tenant instead; always asks you to type the tenant name')
+  .option('--dry-run', 'list what would be deleted and stop')
+  .option('-y, --yes', 'skip the confirmation prompt (never the --live one)')
+  .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.3",
+  "version": "0.6.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,126 @@ 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. remove clears the Test one unless --live is given, and a tenant id of the other kind
+// is refused rather than used, so the flag alone decides which side gets deleted.
+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 isTestTenant = (t) => TEST_SUFFIX.test(t.name ?? '');
+const workspaceSlug = (name) =>
+  String(name ?? '')
+    .replace(TEST_SUFFIX, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+async function resolveTenant(client, workspace, live) {
+  const side = live ? 'Live' : 'Test';
+  if (TENANT_ID.test(workspace)) {
+    const [tenant] = await client.tenants({ id: workspace });
+    if (!tenant) throw new Error(`No tenant with id ${workspace}.`);
+    if (isTestTenant(tenant) === live) {
+      throw new Error(
+        live
+          ? `${workspace} is "${tenant.name}", a Test tenant. Drop --live to clear it.`
+          : `${workspace} is "${tenant.name}", a Live tenant. remove only clears it with --live.`
+      );
+    }
+    return tenant;
+  }
+
+  const wanted = workspaceSlug(workspace);
+  const all = await client.tenants({ maxResults: 1000 });
+  const matches = all.filter((t) => isTestTenant(t) !== live && 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} ${side} 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 ${side} tenant named like "${workspace}". Find it with: camunda tenants -s <name>, then pass its id.`);
+}
+
+// Settles on end of input too. Without that, a script with nothing on stdin leaves the prompt
+// pending and node exits 0 silently, which reads like success.
+async function ask(question) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const closed = new Promise((resolve) => rl.once('close', () => resolve(null)));
+  const answer = await Promise.race([rl.question(question), closed]);
+  rl.close();
+  if (answer === null) out.line('');
+  return answer?.trim() ?? '';
+}
+
+// Clears every open task assigned to one person in a workspace 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 live = Boolean(options.live);
+  const tenant = await resolveTenant(client, workspace, live);
+
+  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, live, assignee, tasks, instanceIds });
+
+  out.heading(`${tenant.name}  ${tenant.id}${live ? '  LIVE' : ''}`);
+  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 (live) {
+    // --yes does not cover this prompt: these are real requests, and a flag carried over from
+    // a Test command line should not be enough to delete them.
+    out.line('');
+    for (const l of out.wrap(
+      `WARNING: "${tenant.name}" is a LIVE tenant. These are real requests, not test data. ` +
+        `Deleting them ends each request for everyone involved in it and cannot be undone.`
+    )) out.problem(l);
+    const answer = await ask(`Are you sure? Type the tenant name "${tenant.name}" to delete ${instanceIds.length} instance(s): `);
+    if (answer !== tenant.name) return out.note('Aborted, that did not match.');
+  } else if (!options.yes) {
+    const expect = String(instanceIds.length);
+    const answer = await ask(`\nDeleting ${expect} instance(s) cannot be undone. Type "${expect}" to confirm: `);
+    if (answer !== 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, live, 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());