@waron97/prbot 3.2.1 → 3.4.0

package/src/agrippa/commands/push.js

@@ -2,14 +2,17 @@ import { mkdirSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 import inquirer from 'inquirer';
 import { getToken } from '../../lib/auth.js';
+import { log } from '../../lib/logger.js';
 import { updateMfa, updatePhase } from '../lib/api.js';
 import { computeChecksum } from '../lib/checksum.js';
 import { loadEffectiveEnv, readConfig, writeConfig } from '../lib/config.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
 import { getProcess } from '../lib/pbApi.js';
 import { localChecksum, remoteChecksumPb } from '../lib/pbProject.js';
 import { projectReader } from '../lib/pbWorkspace.js';
 import { fileExists, readCodeFile } from '../lib/workspace.js';
 import { fetchRemoteCode, selectEntries } from './pull.js';
+import { deploy, pushLrpEntry } from './pushLrp.js';
 import { publish, pushPbEntry } from './pushPb.js';
 
 const BACKUP_DIR = '.backup';
@@ -21,24 +24,28 @@ async function push(opts = {}) {
     // Stale-entry check (a path may be a file for phase/mfa or a dir for pb).
     const stale = config.workspace.filter((e) => !fileExists(e.path));
     if (stale.length) {
-        console.log('\nThe following tracked resources no longer exist on disk:');
-        stale.forEach((e) => console.log(`  - ${e.path}  (${e.name})`));
-        const { cleanup } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'cleanup',
-                message: 'Remove these entries from the workspace config?',
-                default: true,
-            },
-        ]);
-        if (cleanup) {
-            config.workspace = config.workspace.filter((e) => fileExists(e.path));
-            writeConfig(config);
+        log('\nThe following tracked resources no longer exist on disk:');
+        stale.forEach((e) => log(`  - ${e.path}  (${e.name})`));
+        if (opts.nonInteractive) {
+            log('  (non-interactive: leaving them tracked; run interactively to clean up)');
+        } else {
+            const { cleanup } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'cleanup',
+                    message: 'Remove these entries from the workspace config?',
+                    default: true,
+                },
+            ]);
+            if (cleanup) {
+                config.workspace = config.workspace.filter((e) => fileExists(e.path));
+                writeConfig(config);
+            }
         }
     }
 
     if (!config.workspace.length) {
-        console.log('No tracked resources. Run `agrippa clone` first.');
+        log('No tracked resources. Run `agrippa clone` first.');
         return;
     }
 
@@ -46,13 +53,18 @@ async function push(opts = {}) {
         (e) => e.object_type === 'phase' || e.object_type === 'mfa'
     );
     const hasPb = config.workspace.some((e) => e.object_type === 'process_builder');
+    const hasLrp = config.workspace.some((e) => e.object_type === 'long_running_process');
     const ripUrl = process.env.RIP_URL;
     if (hasCode && !ripUrl)
         throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
     if (hasPb && !process.env.PB_URL)
         throw new Error('PB_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+    if (hasLrp && !process.env.IMPORTEXPORT_URL)
+        throw new Error(
+            'IMPORTEXPORT_URL is not configured. Run `prbot init` or set it in agrippa.yaml.'
+        );
 
-    console.log('Fetching remote state...');
+    log('Fetching remote state...');
     const token = await getToken();
 
     const remoteCodeMap = hasCode
@@ -66,6 +78,14 @@ async function push(opts = {}) {
             upstreamMap.set(e.guid, null);
         }
     }
+    const lrpUpstreamMap = new Map();
+    for (const e of config.workspace.filter((x) => x.object_type === 'long_running_process')) {
+        try {
+            lrpUpstreamMap.set(e.name, await fetchUpstream(token, e.name));
+        } catch {
+            lrpUpstreamMap.set(e.name, null);
+        }
+    }
 
     // Classify every entry to a status badge — concern: overwriting remote work.
     const classified = config.workspace.map((entry) => {
@@ -81,6 +101,18 @@ async function push(opts = {}) {
             return { ...entry, upstream, status };
         }
 
+        if (entry.object_type === 'long_running_process') {
+            const upstream = lrpUpstreamMap.get(entry.name) ?? null;
+            const localSemantic = localChecksum(projectReader(entry.path));
+            const remoteSemantic = upstream ? remoteChecksumPb(upstream.payload) : null;
+            const pullChecksum = entry.checksum_at_pull;
+            let status;
+            if (localSemantic === remoteSemantic) status = 'unchanged';
+            else if (pullChecksum === remoteSemantic) status = 'fast-forward';
+            else status = 'conflict';
+            return { ...entry, upstream, status };
+        }
+
         const key = `${entry.object_type}:${entry.id}`;
         const remoteCode = remoteCodeMap.get(key) ?? null;
         const localCode = readCodeFile(entry.path);
@@ -96,22 +128,26 @@ async function push(opts = {}) {
 
     const changed = classified.filter((e) => e.status !== 'unchanged');
     if (!changed.length) {
-        console.log('Nothing to push — everything matches the last-pulled state.');
+        log('Nothing to push — everything matches the last-pulled state.');
         return;
     }
 
-    const selected = await selectEntries(changed, 'push (overwrites remote)', 'push');
+    const selected = await selectEntries(changed, 'push (overwrites remote)', opts);
     if (!selected.length) {
-        console.log('Nothing selected. No changes made.');
+        log('Nothing selected. No changes made.');
         return;
     }
 
     const backupTs = new Date().toISOString().replace(/:/g, '-').replace('T', '_').slice(0, 19);
 
-    // Back up remote code for phase/mfa before overwriting (pb backs up its own
-    // full upstream payload inside pushPbEntry).
+    // Back up remote code for phase/mfa before overwriting (pb/lrp back up
+    // their own full upstream payload inside pushPbEntry/pushLrpEntry).
     for (const entry of selected) {
-        if (entry.object_type !== 'process_builder' && entry.remoteCode != null) {
+        if (
+            entry.object_type !== 'process_builder' &&
+            entry.object_type !== 'long_running_process' &&
+            entry.remoteCode != null
+        ) {
             const backupPath = join(BACKUP_DIR, backupTs, entry.path);
             mkdirSync(dirname(backupPath), { recursive: true });
             writeFileSync(backupPath, (entry.remoteCode ?? '').trim() + '\n', 'utf-8');
@@ -119,15 +155,15 @@ async function push(opts = {}) {
     }
 
     const pushedPb = [];
+    const pushedLrp = [];
     let pushed = 0;
     for (const entry of selected) {
-        const idx = config.workspace.findIndex(
-            (e) =>
-                e.object_type === entry.object_type &&
-                (entry.object_type === 'process_builder'
-                    ? e.guid === entry.guid
-                    : e.id === entry.id)
-        );
+        const idx = config.workspace.findIndex((e) => {
+            if (e.object_type !== entry.object_type) return false;
+            if (entry.object_type === 'process_builder') return e.guid === entry.guid;
+            if (entry.object_type === 'long_running_process') return e.name === entry.name;
+            return e.id === entry.id;
+        });
 
         if (entry.object_type === 'process_builder') {
             const res = await pushPbEntry(token, entry, BACKUP_DIR, backupTs);
@@ -137,13 +173,26 @@ async function push(opts = {}) {
             ]
                 .filter(Boolean)
                 .join(', ');
-            console.log(`  ${entry.name} → saved (draft)${note ? ` [${note}]` : ''}`);
+            log(`  ${entry.name} → saved (draft)${note ? ` [${note}]` : ''}`);
             if (idx !== -1) {
                 config.workspace[idx].checksum_at_pull = res.newChecksum;
                 if (res.newUpdatedDate) config.workspace[idx].updated_date = res.newUpdatedDate;
                 config.workspace[idx].status = res.newStatus || 'draft';
             }
             pushedPb.push({ entry, idx });
+        } else if (entry.object_type === 'long_running_process') {
+            const res = await pushLrpEntry(token, entry, BACKUP_DIR, backupTs);
+            log(`  ${entry.name} → saved`);
+            if (idx !== -1) {
+                config.workspace[idx].checksum_at_pull = res.newChecksum;
+                config.workspace[idx].tenant_id = res.newRow.tenantId;
+                config.workspace[idx].description = res.newRow.description;
+                config.workspace[idx].version = res.newRow.version;
+                config.workspace[idx].status = res.newRow.status;
+            }
+            // deployId is the fresh post-save id (re-resolved by name in
+            // pushLrpEntry); the pre-save id is dead once the save returns.
+            pushedLrp.push({ entry, idx, deployId: res.deployId });
         } else {
             const code = entry.localCode ?? '';
             if (entry.object_type === 'phase') await updatePhase(token, ripUrl, entry.id, code);
@@ -153,15 +202,18 @@ async function push(opts = {}) {
         pushed++;
     }
 
-    console.log(`\nRemote backups written to ${BACKUP_DIR}/${backupTs}/`);
+    log(`\nRemote backups written to ${BACKUP_DIR}/${backupTs}/`);
 
-    // Publish step for pushed wizards (now in "draft").
+    // Publish/deploy step for pushed wizards and LRPs.
     if (pushedPb.length) {
         await handlePublish(token, pushedPb, config, opts);
     }
+    if (pushedLrp.length) {
+        await handleDeploy(token, pushedLrp, config, opts);
+    }
 
     writeConfig(config);
-    console.log(`\nPushed ${pushed} record(s).`);
+    log(`\nPushed ${pushed} record(s).`);
 }
 
 async function handlePublish(token, pushedPb, config, opts) {
@@ -169,6 +221,8 @@ async function handlePublish(token, pushedPb, config, opts) {
         let doPublish;
         if (opts.skipPublish) doPublish = false;
         else if (opts.publish) doPublish = true;
+        else if (opts.nonInteractive)
+            doPublish = false; // no stdin to prompt on; default to safe
         else {
             ({ doPublish } = await inquirer.prompt([
                 {
@@ -182,7 +236,32 @@ async function handlePublish(token, pushedPb, config, opts) {
         if (doPublish) {
             await publish(token, entry.guid);
             if (idx !== -1) config.workspace[idx].status = 'published';
-            console.log(`  published ${entry.name}`);
+            log(`  published ${entry.name}`);
+        }
+    }
+}
+
+async function handleDeploy(token, pushedLrp, config, opts) {
+    for (const { entry, idx, deployId } of pushedLrp) {
+        let doDeploy;
+        if (opts.skipPublish) doDeploy = false;
+        else if (opts.publish) doDeploy = true;
+        else if (opts.nonInteractive)
+            doDeploy = false; // no stdin to prompt on; default to safe
+        else {
+            ({ doDeploy } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'doDeploy',
+                    message: `Deploy "${entry.name}" now?`,
+                    default: false,
+                },
+            ]));
+        }
+        if (doDeploy) {
+            await deploy(token, deployId);
+            if (idx !== -1) config.workspace[idx].status = 'deployed';
+            log(`  deployed ${entry.name}`);
         }
     }
 }

package/src/agrippa/commands/pushLrp.js

@@ -0,0 +1,56 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { deployLrp, resolveLrpByName, saveLrp } from '../lib/lrpApi.js';
+import { localChecksum, recompose } from '../lib/pbProject.js';
+import { projectReader } from '../lib/pbWorkspace.js';
+
+// Push one LRP entry: back up upstream, re-resolve the CURRENT id/tenantId by
+// name (never trust a stored/stale id — it changes on every save/version),
+// and PATCH the recomposed XML back. Returns a summary; deploy is a separate
+// step (see deploy()), mirroring PB's push-then-publish split.
+//
+// The save bumps the version and mints a NEW id, so the pre-save id is stale
+// the moment saveLrp returns. Both the deploy target and the post-save
+// version/status must come from a fresh resolve-by-name AFTER the save — never
+// from the pre-save row or the PATCH response (which does not echo the new id).
+async function pushLrpEntry(token, entry, backupDir, backupTs) {
+    const read = projectReader(entry.path);
+    const localPayload = recompose(read);
+    const upstream = entry.upstream; // { row, payload } from push.js's classification
+
+    if (upstream) {
+        const backupPath = join(backupDir, backupTs, entry.path, 'upstream.xml');
+        mkdirSync(dirname(backupPath), { recursive: true });
+        writeFileSync(backupPath, upstream.payload.built_page, 'utf-8');
+    }
+
+    // Re-resolve immediately before saving — the row captured during
+    // classification may be stale if something else saved in between.
+    const row = await resolveLrpByName(token, entry.name);
+    const description = upstream?.row?.description ?? entry.description ?? '';
+    const saved = await saveLrp(
+        token,
+        { ...row, bpmnFileSvg: entry.svg ?? row.bpmnFileSvg },
+        localPayload.built_page,
+        description
+    );
+
+    // The save minted a new id and bumped the version — re-resolve by name to
+    // get the fresh row. deployBpmn must target this new id (the pre-save id is
+    // now dead: deploying it 200s but activates nothing), and the workspace
+    // entry's version/status must come from here, not the stale pre-save row.
+    const deployRow = await resolveLrpByName(token, entry.name);
+
+    return {
+        newChecksum: localChecksum(read),
+        newRow: { ...deployRow, description },
+        saved,
+        deployId: deployRow.id,
+    };
+}
+
+function deploy(token, id) {
+    return deployLrp(token, id);
+}
+
+export { pushLrpEntry, deploy };

package/src/agrippa/commands/repair.js

@@ -1,3 +1,4 @@
+import { log } from '../../lib/logger.js';
 import { readConfig, writeConfig } from '../lib/config.js';
 import { fileExists } from '../lib/workspace.js';
 
@@ -9,16 +10,16 @@ async function repair() {
     config.workspace = config.workspace.filter((entry) => fileExists(entry.path));
 
     if (!stale.length) {
-        console.log('No stale entries found.');
+        log('No stale entries found.');
         return;
     }
 
     for (const entry of stale) {
-        console.log(`  removed: ${entry.path} (${entry.name})`);
+        log(`  removed: ${entry.path} (${entry.name})`);
     }
 
     writeConfig(config);
-    console.log(
+    log(
         `Removed ${stale.length} stale entr${stale.length === 1 ? 'y' : 'ies'} (${before} → ${config.workspace.length}).`
     );
 }

package/src/agrippa/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { program } from 'commander';
+import { error } from '../lib/logger.js';
 import { clone } from './commands/clone.js';
 import { diff } from './commands/diff.js';
 import { init } from './commands/init.js';
@@ -24,7 +25,7 @@ const require = createRequire(import.meta.url);
 const { version } = require('../../package.json');
 
 process.on('unhandledRejection', (err) => {
-    console.error(`Error: ${err.message}`);
+    error(`Error: ${err.message}`);
     process.exit(1);
 });
 
@@ -35,23 +36,26 @@ program
     .description('Create agrippa.yaml workspace config in the current directory')
     .action(() =>
         init().catch((err) => {
-            console.error(`Error: ${err.message}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
 
 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}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
@@ -59,21 +63,29 @@ program
 program
     .command('pull')
     .description('Pull remote changes into local files')
-    .action(() =>
-        pull().catch((err) => {
-            console.error(`Error: ${err.message}`);
+    .option(
+        '--non-interactive',
+        'No prompts; auto-select safe (fast-forward) entries and fail if any is in conflict'
+    )
+    .action((opts) =>
+        pull(opts).catch((err) => {
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
 
 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)')
+    .option(
+        '--non-interactive',
+        'No prompts; auto-select safe (fast-forward) entries and fail if any is in conflict'
+    )
     .action((opts) =>
         push(opts).catch((err) => {
-            console.error(`Error: ${err.message}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
@@ -83,7 +95,7 @@ program
     .description('Show differences between local files and remote code')
     .action((path) =>
         diff(path).catch((err) => {
-            console.error(`Error: ${err.message}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
@@ -93,7 +105,7 @@ program
     .description('Initialize a phase with default code template and result vars')
     .action(() =>
         initPhase().catch((err) => {
-            console.error(`Error: ${err.message}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
@@ -103,30 +115,34 @@ program
     .description('Remove stale workspace entries where local file no longer exists')
     .action(() =>
         repair().catch((err) => {
-            console.error(`Error: ${err.message}`);
+            error(`Error: ${err.message}`);
             process.exit(1);
         })
     );
 
-// ---- 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}`);
+    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 +152,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 +169,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 +177,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 +185,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();