@waron97/prbot 3.0.4 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@waron97/prbot",
-    "version": "3.0.4",
+    "version": "3.1.0",
     "description": "",
     "main": "index.js",
     "scripts": {

package/src/agrippa/commands/initPhase.js

@@ -114,7 +114,7 @@ async function initPhase() {
     // Resolve result objects — API may return IDs or full objects
     let results = phase.allowed_phase_result_ids || [];
     if (results.length > 0 && typeof results[0] === 'number') {
-        results = await getPhaseResults(token, ripUrl, phase.id);
+        results = await getPhaseResults(token, ripUrl, results);
     }
 
     const code = generateCode(results);

package/src/agrippa/lib/api.js

@@ -48,11 +48,12 @@ function updateMfa(token, ripUrl, mfaId, code) {
     return makeRequest('POST', '/symple.workflow/update_mfa', token, ripUrl, { id: mfaId, code });
 }
 
-async function getPhaseResults(token, ripUrl, phaseId) {
+async function getPhaseResults(token, ripUrl, ids) {
+    if (!ids || ids.length === 0) return [];
     try {
         return await makeRequest(
             'GET',
-            `/symple.triplet.phase.result/*?_filter_=[('code_phase_id', '=', ${phaseId})]`,
+            `/symple.triplet.phase.result/*?_filter_=[('id', 'in', [${ids.join(',')}])]`,
             token,
             ripUrl,
         );

package/src/commands/export.js

@@ -2,9 +2,10 @@ import { exportPb } from './exportPb.js';
 import { exportImperex } from './exportImperex.js';
 import { exportEmailTemplates } from './exportEmailTemplates.js';
 import { exportWorkflow } from './exportWorkflow.js';
+import { exportLrp } from './exportLrp.js';
 
 function exportRip() {
     console.log('Not implemented yet.');
 }
 
-export { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow };
+export { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow, exportLrp };

package/src/commands/exportLrp.js

@@ -0,0 +1,185 @@
+import fs from 'fs/promises';
+import path from 'path';
+import fetch from 'node-fetch';
+import search from '@inquirer/search';
+import { getToken } from '../lib/auth.js';
+import { execGit } from '../lib/git.js';
+import { resolveAddonsPath } from '../lib/addons.js';
+import { fuzzyMatch } from '../lib/fuzzy.js';
+import { CONFIG_DIR } from '../config.js';
+
+const CACHE_FILE = path.join(CONFIG_DIR, 'lrp_processes_cache.json');
+
+function getSymphonyBase() {
+    const url = process.env.IMPORTEXPORT_URL;
+    if (!url) throw new Error('IMPORTEXPORT_URL not configured');
+    const parsed = new URL(url);
+    return `${parsed.protocol}//${parsed.host}`;
+}
+
+async function fetchProcessList(token, signal) {
+    const base = getSymphonyBase();
+    const params = encodeURIComponent(JSON.stringify({ page: 1, size: 1000, sorters: [], filters: [] }));
+    const otherfilters = encodeURIComponent(
+        JSON.stringify([
+            { field: 'id', type: '=', value: null },
+            { field: 'name', type: 'like', value: 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 response = await fetch(url, {
+        headers: {
+            accept: 'application/json',
+            Authorization: `Bearer ${token}`,
+        },
+        signal,
+    });
+    if (!response.ok) throw new Error(await response.text());
+    const json = await response.json();
+
+    const items = [];
+    for (const row of json.data || []) {
+        for (let i = 1; i <= 4; i++) {
+            const cell = row[`cellContent${i}`];
+            if (cell && cell.id && cell.name) {
+                items.push({ id: String(cell.id), name: cell.name });
+            }
+        }
+    }
+    return items;
+}
+
+async function loadCache() {
+    try {
+        const data = await fs.readFile(CACHE_FILE, 'utf-8');
+        return JSON.parse(data);
+    } catch {
+        return null;
+    }
+}
+
+async function saveCache(items) {
+    try {
+        await fs.mkdir(path.dirname(CACHE_FILE), { recursive: true });
+        await fs.writeFile(CACHE_FILE, JSON.stringify(items));
+    } catch {
+        // non-fatal
+    }
+}
+
+async function fetchProcessDetail(id, token) {
+    const base = getSymphonyBase();
+    const url = `${base}/symphony/restInfo/ajax/tabulator/id/${id}?connector=SymphBpmnFileTabCon&modelroot=/management/development/edit`;
+    const response = await fetch(url, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!response.ok) throw new Error(await response.text());
+    return response.text();
+}
+
+function extractBpmnData(jsText) {
+    const valueMatch = jsText.match(/doc\.value\s*=\s*'([^']+)'/);
+    if (!valueMatch) throw new Error('Could not find doc.value in response');
+
+    const filenameMatch = jsText.match(/filename\.value\s*=\s*'([^']+)'/);
+    if (!filenameMatch) throw new Error('Could not find filename.value in response');
+
+    const xml = Buffer.from(valueMatch[1], 'base64').toString('utf-8');
+    const filename = filenameMatch[1];
+    return { xml, filename };
+}
+
+async function findExistingFile(baseDir, filename) {
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+            return null;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const found = await walk(full);
+                if (found) return found;
+            } else if (entry.name === filename) {
+                return full;
+            }
+        }
+        return null;
+    }
+    return walk(baseDir);
+}
+
+async function exportLrp(opts) {
+    const token = await getToken();
+
+    // choices is a mutable ref so source() sees background updates live
+    let choices = [];
+
+    const cached = await loadCache();
+
+    const bgController = new AbortController();
+
+    if (cached) {
+        choices = cached.map((p) => ({ name: p.name, value: p.id }));
+        console.log(`Loaded ${choices.length} processes from cache. Fetching fresh list in background (~1 min) — results update as you type.`);
+        fetchProcessList(token, bgController.signal)
+            .then(async (fresh) => {
+                await saveCache(fresh);
+                const updated = fresh.map((p) => ({ name: p.name, value: p.id }));
+                choices.length = 0;
+                choices.push(...updated);
+            })
+            .catch(() => {});
+    } else {
+        console.log('No cache found. Fetching process list (~1 min)...');
+        const items = await fetchProcessList(token);
+        await saveCache(items);
+        choices = items.map((p) => ({ name: p.name, value: p.id }));
+        console.log(`Loaded ${choices.length} processes.`);
+    }
+
+    const selectedId = await search({
+        message: 'Select LRP process to export:',
+        source: async (input) => {
+            if (!input) return choices;
+            return choices.filter((c) => fuzzyMatch(c.name, input));
+        },
+    });
+
+    console.log('Fetching process detail...');
+    const jsText = await fetchProcessDetail(selectedId, token);
+    const { xml, filename } = extractBpmnData(jsText);
+    const bpmnFilename = `${filename.replace(/^B2WA_/, '')}.bpmn20.xml`;
+
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    const processesDir = path.join(ADDONS_PATH, '.cloudbuild', 'symphony', 'B2WA', 'processes');
+
+    const existing = await findExistingFile(processesDir, bpmnFilename);
+    let savePath;
+    if (existing) {
+        savePath = existing;
+        await fs.writeFile(savePath, xml, 'utf-8');
+        console.log(`Updated: ${savePath}`);
+    } else {
+        savePath = path.join(processesDir, 'all', bpmnFilename);
+        await fs.mkdir(path.dirname(savePath), { recursive: true });
+        await fs.writeFile(savePath, xml, 'utf-8');
+        console.log(`Created: ${savePath}`);
+    }
+
+    if (opts.commit !== false) {
+        await execGit(['add', savePath], ADDONS_PATH);
+        await execGit(['commit', '-m', '[IMP][.cloudbuild] Update long running process'], ADDONS_PATH);
+        console.log('Committed.');
+    }
+
+    bgController.abort();
+}
+
+export { exportLrp };

package/src/commands/exportWorkflow.js

@@ -42,7 +42,7 @@ async function exportWorkflow(opts) {
     }
 
     if (bumpLevel && bumpLevel !== 'none') {
-        await verbot(module, bumpLevel);
+        await verbot(module, bumpLevel, opts);
     }
 }
 

package/src/commands/ver.js

@@ -3,7 +3,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { resolveAddonsPath } from '../lib/addons.js';
 
-async function verbot(module_name, level) {
+async function verbot(module_name, level, opts = {}) {
     if (!['major', 'minor', 'patch'].includes(level)) {
         throw new Error('Level must be one of major, minor, patch');
     }
@@ -52,6 +52,8 @@ async function verbot(module_name, level) {
     await fs.writeFile(manifestPath, newContent);
     console.log(`Updated version: ${currentVersion} -> ${newVersion}`);
 
+    if (opts.commit === false) return;
+
     await new Promise((resolve, reject) => {
         execFile('git', ['add', manifestPath], { cwd: ADDONS_PATH }, (error) => {
             if (error) reject(error);

package/src/index.js

@@ -5,7 +5,7 @@ import { configDotenv } from 'dotenv';
 import { autopr } from './commands/autopr.js';
 import { changelog } from './commands/changelog.js';
 import { commit } from './commands/commit.js';
-import { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow } from './commands/export.js';
+import { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow, exportLrp } from './commands/export.js';
 import { init } from './commands/init.js';
 import { main as prMain } from './commands/pr.js';
 import { verbot } from './commands/ver.js';
@@ -119,6 +119,15 @@ exportCmd
         });
     });
 
+exportCmd
+    .command('lrp')
+    .option('--no-commit')
+    .action((opts) => {
+        exportLrp(opts).catch((err) => {
+            throw err;
+        });
+    });
+
 exportCmd
     .command('email-templates')
     .option('--no-commit')