@waron97/prbot 3.2.1 → 3.4.0

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.

package/src/agrippa/lib/pbLayout.js

@@ -154,7 +154,14 @@ async function autoLayout(structure) {
                 targets: [e.target],
                 sourcePort,
                 labels: e.name
-                    ? [{ id: `${e.id}__lbl`, text: e.name, width: Math.min(e.name.length * 6, 140), height: 14 }]
+                    ? [
+                          {
+                              id: `${e.id}__lbl`,
+                              text: e.name,
+                              width: Math.min(e.name.length * 6, 140),
+                              height: 14,
+                          },
+                      ]
                     : [],
                 layoutOptions: {
                     'elk.layered.priority.straightness': isHappy ? '10' : 1,