@waron97/prbot 3.2.1 → 3.3.0

package/src/agrippa/index.js

@@ -42,13 +42,16 @@ program
 
 program
     .command('clone')
-    .description('Clone a phase, MFA, or process-builder wizard into this workspace')
+    .description(
+        'Clone a phase, MFA, process-builder wizard, or long-running process into this workspace'
+    )
     .option('--phase', 'Clone a phase (select a workflow)')
     .option('--mfa', 'Clone a Model Function Access record')
     .option('--pb', 'Clone a process-builder wizard')
+    .option('--lrp', 'Clone a long-running process')
     .option('--id <id>', 'Record ID to clone (phase/mfa)')
-    .option('--name <document_id>', 'Process-builder document_id to clone (with --pb)')
-    .option('--path <path>', 'Destination path (file for MFA, base dir for workflow/pb)')
+    .option('--name <name>', 'document_id (--pb) or process name (--lrp) to clone')
+    .option('--path <path>', 'Destination path (file for MFA, base dir for workflow/pb/lrp)')
     .action((opts) =>
         clone(opts).catch((err) => {
             console.error(`Error: ${err.message}`);
@@ -68,9 +71,9 @@ program
 
 program
     .command('push')
-    .description('Push local changes to RIP / Process Builder (backs up remote first)')
-    .option('--publish', 'Auto-publish pushed process-builder wizards')
-    .option('--skip-publish', 'Skip publishing pushed wizards (no prompt)')
+    .description('Push local changes to RIP / Process Builder / LRP (backs up remote first)')
+    .option('--publish', 'Auto-publish pushed wizards and auto-deploy pushed LRPs')
+    .option('--skip-publish', 'Skip publishing/deploying pushed wizards and LRPs (no prompt)')
     .action((opts) =>
         push(opts).catch((err) => {
             console.error(`Error: ${err.message}`);
@@ -108,25 +111,29 @@ program
         })
     );
 
-// ---- pb: local editing helpers for a cloned process-builder wizard ----
+// ---- pb: local editing helpers for a cloned process-builder wizard or LRP ----
 const die = (err) => {
     console.error(`Error: ${err.message}`);
     process.exit(1);
 };
 const pb = program
     .command('pb')
-    .description('Edit a cloned process-builder wizard (local; run `pb format` after edits)');
+    .description(
+        'Edit a cloned process-builder wizard or long-running process (local; run `pb format` after edits)'
+    );
 
 pb.command('format')
     .description('Auto-lay-out the diagram (left→right) and rewrite geometry')
-    .option('--pb <document_id>', 'Target wizard (else single-entry / fuzzy prompt)')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP (else single-entry / fuzzy prompt)')
     .action((opts) => pbFormat(opts).catch(die));
 
 pb.command('add')
     .description('Add a node (scaffolds script/page); stub geometry, run format after')
     .requiredOption(
         '--type <type>',
-        'Node type: scriptTask|serviceTask|userTask|exclusiveGateway|subProcess|transaction|startEvent|endEvent|boundaryEvent'
+        'Node type: scriptTask|serviceTask|userTask|exclusiveGateway|subProcess|transaction|' +
+            'startEvent|endEvent|boundaryEvent|intermediateCatchEvent|intermediateThrowEvent|' +
+            'callActivity|parallelGateway|eventBasedGateway (userTask is process-builder only)'
     )
     .option('--name <name>', 'Node name')
     .option('--parent <id>', 'Place inside this subProcess/transaction')
@@ -136,13 +143,13 @@ pb.command('add')
             'exactly one edge must already run --from → --to)'
     )
     .option('--to <id>', 'Insert between two already-connected nodes: target id (requires --from)')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbAdd(opts).catch(die));
 
 pb.command('rm')
     .description('Remove a node, its edges, and its script/page files')
     .requiredOption('--id <id>', 'Node id to remove')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbRemove(opts).catch(die));
 
 pb.command('connect')
@@ -153,7 +160,7 @@ pb.command('connect')
     .option('--condition <expr>', 'Condition expression, e.g. ${isAlive}')
     .option('--condition-type <type>', 'xsi:type for the condition (default tFormalExpression)')
     .option('--default', 'Mark this as the source gateway default flow')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbConnect(opts).catch(die));
 
 pb.command('disconnect')
@@ -161,7 +168,7 @@ pb.command('disconnect')
     .option('--id <id>', 'Edge id to remove')
     .option('--from <id>', 'Source node id')
     .option('--to <id>', 'Target node id')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbDisconnect(opts).catch(die));
 
 pb.command('set-default')
@@ -169,23 +176,25 @@ pb.command('set-default')
     .option('--id <id>', 'Edge id to mark default')
     .option('--from <id>', 'Source gateway id')
     .option('--to <id>', 'Target node id')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbSetDefault(opts).catch(die));
 
 pb.command('lint')
-    .description('Check diagram for structural issues (edge names, incoming-edge rules, gateway rules)')
-    .option('--pb <document_id>', 'Target wizard')
+    .description(
+        'Check diagram for structural issues (edge names, incoming-edge rules, gateway rules)'
+    )
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbLint(opts).catch(die));
 
 pb.command('ls')
     .description('List nodes and edges (discover ids without reading the YAML)')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbList(opts).catch(die));
 
 pb.command('preview')
     .description('Render the diagram to an SVG (dev check of format output)')
     .option('--out <file>', 'Output path (default <project>/preview.svg)')
-    .option('--pb <document_id>', 'Target wizard')
+    .option('--pb <document_id_or_name>', 'Target wizard/LRP')
     .action((opts) => pbPreview(opts).catch(die));
 
 program.parse();

package/src/agrippa/lib/lrpApi.js

@@ -0,0 +1,153 @@
+// Symphony long-running-process (LRP) API client. Base = protocol+host of
+// IMPORTEXPORT_URL (the tabulator/deployBpmn endpoints live on the Symphony
+// host itself, not under the import/export path). Auth uses the same
+// Keycloak bearer as everything else (getToken()).
+//
+// Unlike PBs, LRPs have no stable guid: the tabulator `id` changes on every
+// save/version bump (confirmed live — a re-fetched id differs from a
+// previously captured one for the same process). The process `name` is the
+// only stable identifier, so every write re-resolves the current id/tenantId
+// by name immediately before acting on it.
+
+import fetch from 'node-fetch';
+
+function getSymphonyBase() {
+    const url = process.env.IMPORTEXPORT_URL;
+    if (!url) throw new Error('IMPORTEXPORT_URL is not configured. Run `prbot init`.');
+    const parsed = new URL(url);
+    return `${parsed.protocol}//${parsed.host}`;
+}
+
+// List/search processes by name (server-side `like` filter when nameFilter is
+// set; unfiltered page otherwise). Returns the richer per-row fields the save
+// body needs (tenantId, svg), not just id/name.
+async function listLrps(token, nameFilter, signal) {
+    const base = getSymphonyBase();
+    const size = nameFilter ? 20 : 12;
+    const params = encodeURIComponent(JSON.stringify({ page: 1, size, sorters: [], filters: [] }));
+    const otherfilters = encodeURIComponent(
+        JSON.stringify([
+            { field: 'id', type: '=', value: null },
+            { field: 'name', type: 'like', value: nameFilter ?? null },
+            { field: 'tenantId', type: '=', value: null },
+            { field: 'latestVersion', type: '=', value: true },
+        ])
+    );
+    const othersort = encodeURIComponent(
+        JSON.stringify({ field: 'lastModifiedDate', dir: 'desc' })
+    );
+    const url = `${base}/symphony/restInfo/ajax/tabulator?params=${params}&connector=SymphBpmnFileTabCon&otherfilters=${otherfilters}&card=true&othersort=${othersort}`;
+
+    const res = await fetch(url, {
+        headers: { accept: 'application/json', Authorization: `Bearer ${token}` },
+        signal,
+    });
+    if (!res.ok) throw new Error(`LRP list failed with ${res.status}: ${await res.text()}`);
+    const json = await res.json();
+
+    const rows = [];
+    for (const row of json.data || []) {
+        for (let i = 1; i <= 4; i++) {
+            const cell = row[`cellContent${i}`];
+            if (cell && cell.id && cell.name) {
+                rows.push({
+                    id: String(cell.id),
+                    name: cell.name,
+                    tenantId: cell.tenantId,
+                    version: cell.version,
+                    status: cell.status,
+                    bpmnFileSvg: cell.bpmnFileSvg,
+                });
+            }
+        }
+    }
+    return rows;
+}
+
+// Resolve the current row for a process by its stable name (exact match
+// against the server-side `like` search results) — the id-by-name lookup
+// that replaces PB's guid-based addressing everywhere.
+async function resolveLrpByName(token, name) {
+    const rows = await listLrps(token, name);
+    const row = rows.find((r) => r.name === name);
+    if (!row) throw new Error(`No long-running process found with name "${name}"`);
+    return row;
+}
+
+// Fetch the full BPMN XML + description for one process by id. The endpoint
+// returns an HTML/JS fragment (not JSON) — the real payload is a base64
+// `doc.value` assignment plus a set of `bpmn_*` hidden inputs.
+async function getLrpXml(token, id) {
+    const base = getSymphonyBase();
+    const url = `${base}/symphony/restInfo/ajax/tabulator/id/${id}?connector=SymphBpmnFileTabCon&modelroot=/management/development/edit`;
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+    if (!res.ok) throw new Error(`LRP detail fetch failed with ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+
+    const docMatch = text.match(/doc\.value\s*=\s*'([^']+)'/);
+    if (!docMatch) throw new Error('Could not find doc.value in LRP detail response');
+    const filenameMatch = text.match(/filename\.value\s*=\s*'([^']+)'/);
+    if (!filenameMatch) throw new Error('Could not find filename.value in LRP detail response');
+    const descMatch = text.match(/name="bpmn_description"\s+value="([^"]*)"/);
+
+    return {
+        xml: Buffer.from(docMatch[1], 'base64').toString('utf-8'),
+        filename: filenameMatch[1],
+        description: descMatch ? descMatch[1] : '',
+    };
+}
+
+// Save (PATCH) the wizard's BPMN back to Symphony. `row` must carry the
+// CURRENT id/tenantId (re-resolved by name immediately before this call —
+// see resolveLrpByName) and `bpmnFileSvg` (the last-known diagram thumbnail,
+// echoed back unchanged per the agreed approach — it's display-only, the
+// server deploys from the XML, not the SVG). `newVersion:false` saves the
+// process in place rather than creating a new version.
+async function saveLrp(token, row, xml, description = '') {
+    const base = getSymphonyBase();
+    const url = `${base}/symphony/restInfo/ajax/tabulator/${row.id}?connector=SymphBpmnFileTabCon`;
+    const body = {
+        id: row.id,
+        tenantId: row.tenantId,
+        newVersion: false,
+        description,
+        name: row.name,
+        bpmnFile: Buffer.from(xml, 'utf-8').toString('base64'),
+        bpmnFileSvg: row.bpmnFileSvg ?? '',
+        oldTenantId: row.tenantId,
+    };
+    const res = await fetch(url, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(`LRP save failed with ${res.status}: ${await res.text()}`);
+    const responseText = await res.text();
+    return responseText ? JSON.parse(responseText) : null;
+}
+
+// Resolve-by-name + fetch detail in one call — the shape both pull's
+// classification step and pullLrpEntry/pushLrpEntry need: the current row
+// (id/tenantId/svg, re-resolved fresh — never trust a stale one) plus a
+// decompose-ready payload.
+async function fetchUpstream(token, name) {
+    const row = await resolveLrpByName(token, name);
+    const { xml, description } = await getLrpXml(token, row.id);
+    return { row: { ...row, description }, payload: { built_page: xml } };
+}
+
+// Deploy a saved process so live consumers see the latest version.
+async function deployLrp(token, id) {
+    const base = getSymphonyBase();
+    const url = `${base}/symphony/restInfo/ajax/deployBpmn`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ id }),
+    });
+    if (!res.ok) throw new Error(`LRP deploy failed with ${res.status}: ${await res.text()}`);
+    const responseText = await res.text();
+    return responseText ? JSON.parse(responseText) : null;
+}
+
+export { listLrps, resolveLrpByName, getLrpXml, saveLrp, deployLrp, fetchUpstream };

package/src/agrippa/lib/pbEdit.js

@@ -14,6 +14,7 @@
 
 import { stringify as yamlStringify } from 'yaml';
 import { pad, toSlug } from './pbProject.js';
+import { SCRIPT_TEMPLATE } from './pbScriptTemplate.js';
 
 // Fixed element sizes (measured across all fixtures). Containers are sized by
 // the layout engine; we seed a small default so a stubbed clone stays valid.
@@ -27,6 +28,12 @@ const SIZE = {
     userTask: [84, 84],
     subProcess: [350, 200],
     transaction: [350, 200],
+    // LRP-only (measured across the real LRP corpus):
+    intermediateCatchEvent: [36, 36],
+    intermediateThrowEvent: [36, 36],
+    callActivity: [84, 84],
+    parallelGateway: [50, 50],
+    eventBasedGateway: [50, 50],
 };
 
 // BPMN id prefixes by node type (mirrors the upstream naming convention).
@@ -40,6 +47,11 @@ const PREFIX = {
     userTask: 'UserTask',
     subProcess: 'SubProcess',
     transaction: 'Transaction',
+    intermediateCatchEvent: 'IntermediateCatchEvent',
+    intermediateThrowEvent: 'IntermediateThrowEvent',
+    callActivity: 'CallActivity',
+    parallelGateway: 'ParallelGateway',
+    eventBasedGateway: 'EventBasedGateway',
 };
 
 const CONTAINER = new Set(['subProcess', 'transaction']);
@@ -126,7 +138,7 @@ function nextScriptSeq(existingScriptFiles) {
 
 // ---------- add ----------
 
-// Add a node. For scriptTask, scaffolds an empty script file and refs it. For
+// Add a node. For scriptTask, scaffolds a templated script file and refs it. For
 // userTask, scaffolds a minimal page file + a manifest page entry (guid=null →
 // push will create it upstream). Container nodes start empty + expanded.
 function addNode(structure, manifest, opts, ctx = {}) {
@@ -144,7 +156,7 @@ function addNode(structure, manifest, opts, ctx = {}) {
     if (type === 'scriptTask') {
         const seq = nextScriptSeq(ctx.existingScripts);
         const file = `scripts/${pad(seq)}_${toSlug(name || id)}.js`;
-        writes[file] = '';
+        writes[file] = SCRIPT_TEMPLATE;
         node.script = file;
     } else if (type === 'userTask') {
         const formKey = toSlug(name || id);
@@ -434,19 +446,24 @@ function lintEdgeNames(structure) {
         for (const e of outs) {
             if (e.id === def) continue;
             if (!e.name) {
-                issues.push(
-                    `${n.id} → ${e.target} (${e.id}): non-default flow has no name.`
-                );
+                issues.push(`${n.id} → ${e.target} (${e.id}): non-default flow has no name.`);
             }
         }
     });
     return issues;
 }
 
+// Gateway types that legitimately fan multiple flows into one node (a "join").
+// parallelGateway/eventBasedGateway joins are common in the real LRP corpus
+// (61 occurrences) — only exclusiveGateway's merge semantics need a lint rule.
+const JOIN_CAPABLE_GATEWAYS = new Set(['exclusiveGateway', 'parallelGateway', 'eventBasedGateway']);
+
 // Flag incoming-edge violations:
-// - Only exclusiveGateway may have >1 incoming flows.
+// - Only a gateway may have >1 incoming flows (plain tasks/events are 1-in).
 // - An exclusiveGateway may not have both >1 incoming AND >1 outgoing (pick one
-//   direction for merging or splitting, not both at once).
+//   direction for merging or splitting, not both at once) — parallel/event-based
+//   gateways may legitimately fork-then-join across the diagram, so this
+//   specific rule stays scoped to exclusiveGateway.
 function lintIncomingEdges(structure) {
     const inCount = {};
     const outCount = {};
@@ -461,9 +478,9 @@ function lintIncomingEdges(structure) {
     eachNode(structure.nodes, null, (n) => {
         const inc = inCount[n.id] || 0;
         const out = outCount[n.id] || 0;
-        if (inc > 1 && n.type !== 'exclusiveGateway') {
+        if (inc > 1 && !JOIN_CAPABLE_GATEWAYS.has(n.type)) {
             issues.push(
-                `${n.id} (${n.name || n.type}): only exclusiveGateway may have multiple incoming flows (has ${inc}).`
+                `${n.id} (${n.name || n.type}): only a gateway may have multiple incoming flows (has ${inc}).`
             );
         }
         if (n.type === 'exclusiveGateway' && inc > 1 && out > 1) {
@@ -477,7 +494,11 @@ function lintIncomingEdges(structure) {
 
 // Run all lint rules and return combined issues.
 function lintAll(structure) {
-    return [...lintGateways(structure), ...lintEdgeNames(structure), ...lintIncomingEdges(structure)];
+    return [
+        ...lintGateways(structure),
+        ...lintEdgeNames(structure),
+        ...lintIncomingEdges(structure),
+    ];
 }
 
 // Remove an edge by id, or by --from/--to pair.