camunda-cli 0.5.0 → 0.6.0

package/PANDUAN.md

@@ -157,12 +157,16 @@ Untuk mengosongkan inbox satu penguji di AlurKerja sekaligus, tanpa peduli prose
 ```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.
+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.
 

package/README.md

@@ -176,7 +176,9 @@ a process in one go, which matters because testing a model leaves a trail of the
 `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
+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

package/bin/camunda.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.5.0')
+  .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()
@@ -132,9 +132,10 @@ withTenant(
 
 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)")
+  .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')
+  .option('-y, --yes', 'skip the confirmation prompt (never the --live one)')
   .action(removeCommand);
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camunda-cli",
-  "version": "0.5.0",
+  "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/commands/instances.js

@@ -188,10 +188,11 @@ export async function cancelCommand(id, options) {
 }
 
 // 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.
+// 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, '')
@@ -199,42 +200,59 @@ const workspaceSlug = (name) =>
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-+|-+$/g, '');
 
-async function resolveTestTenant(client, workspace) {
+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 (!TEST_SUFFIX.test(tenant.name ?? '')) {
-      throw new Error(`${workspace} is "${tenant.name}", a Live tenant. remove only clears "(TEST)" tenants.`);
+    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) => TEST_SUFFIX.test(t.name ?? '') && workspaceSlug(t.name) === wanted);
+  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} Test tenants. Pass the tenant id instead:\n${list}`);
+    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 Test tenant named like "${workspace}". Find it with: camunda tenants -s <name>, then pass its id.`);
+  throw new Error(`No ${side} 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.
+// 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 tenant = await resolveTestTenant(client, workspace);
+  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, assignee, tasks, instanceIds });
+  if (out.isJsonMode() && options.dryRun) return out.json({ tenant, live, assignee, tasks, instanceIds });
 
-  out.heading(`${tenant.name}  ${tenant.id}`);
+  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}.`);
 
@@ -248,14 +266,20 @@ export async function removeCommand(workspace, assignee, options) {
 
   if (options.dryRun) return out.note('\nDry run, nothing deleted.');
 
-  if (!options.yes) {
-    const rl = createInterface({ input: stdin, output: stdout });
+  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 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.');
+    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;
@@ -274,7 +298,7 @@ export async function removeCommand(workspace, assignee, options) {
   const left = await client.tasks({ tenantIdIn: tenant.id, assignee });
 
   if (out.isJsonMode()) {
-    return out.json({ tenant, assignee, removed, alreadyGone: gone, failures, remainingTasks: left.length });
+    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}`);