@waron97/prbot 3.2.0 → 3.3.0

package/src/agrippa/commands/push.js

@@ -5,11 +5,13 @@ import { getToken } from '../../lib/auth.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 } from '../lib/pbProject.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';
@@ -46,11 +48,16 @@ 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...');
     const token = await getToken();
@@ -66,17 +73,37 @@ 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) => {
         if (entry.object_type === 'process_builder') {
             const upstream = upstreamMap.get(entry.guid) ?? null;
-            const local = localChecksum(projectReader(entry.path));
-            const localChanged = entry.checksum_at_pull !== local;
-            const remoteChanged = !upstream || upstream.updated_date !== entry.updated_date;
+            const localSemantic = localChecksum(projectReader(entry.path));
+            const remoteSemantic = upstream ? remoteChecksumPb(upstream) : null;
+            const pullChecksum = entry.checksum_at_pull;
             let status;
-            if (!localChanged && !remoteChanged) status = 'unchanged';
-            else if (!remoteChanged) status = 'fast-forward';
+            if (localSemantic === remoteSemantic) status = 'unchanged';
+            else if (pullChecksum === remoteSemantic) status = 'fast-forward';
+            else status = 'conflict';
+            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 };
         }
@@ -88,8 +115,7 @@ async function push(opts = {}) {
         const localChecksumVal = computeChecksum(localCode ?? '');
         const pullChecksum = entry.checksum_at_pull;
         let status;
-        if (pullChecksum === localChecksumVal && pullChecksum === remoteChecksum)
-            status = 'unchanged';
+        if (localChecksumVal === remoteChecksum) status = 'unchanged';
         else if (pullChecksum === remoteChecksum) status = 'fast-forward';
         else status = 'conflict';
         return { ...entry, remoteCode, localCode, status };
@@ -109,10 +135,14 @@ async function push(opts = {}) {
 
     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');
@@ -120,15 +150,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);
@@ -145,6 +175,19 @@ async function push(opts = {}) {
                 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);
+            console.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);
@@ -156,10 +199,13 @@ async function push(opts = {}) {
 
     console.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).`);
@@ -188,4 +234,27 @@ async function handlePublish(token, pushedPb, config, opts) {
     }
 }
 
+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 {
+            ({ 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';
+            console.log(`  deployed ${entry.name}`);
+        }
+    }
+}
+
 export { push };

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/index.js

@@ -10,6 +10,7 @@ import {
     pbConnect,
     pbDisconnect,
     pbFormat,
+    pbLint,
     pbList,
     pbPreview,
     pbRemove,
@@ -41,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}`);
@@ -67,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}`);
@@ -107,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')
@@ -135,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')
@@ -152,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')
@@ -160,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')
@@ -168,18 +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_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 };