@mseep/bw-modeling-mcp 0.8.0

package/dist/tools/request_monitor.js

@@ -0,0 +1,174 @@
+import { createClientFromEnv } from '../bw-client.js';
+// Every GET in the runtime manage family returns HTTP 415 unless it carries
+// Content-Type: application/json, even though GET has no body.
+const GET_HEADERS = { 'Content-Type': 'application/json', Accept: '*/*' };
+// Module-scope caches for the system domain text maps. The status tables are
+// stable for the process lifetime, so they are fetched once and reused.
+let requestStatusMap = null;
+let processStatusMap = null;
+async function fetchDomainMap(client, domain) {
+    const url = `/sap/bc/http/sap/bw4/v1/system/domains/${domain}/texts`;
+    const result = await client.rawGet(url, GET_HEADERS);
+    const parsed = JSON.parse(result.body);
+    const map = new Map();
+    for (const entry of parsed) {
+        if (entry.key !== undefined) {
+            map.set(entry.key, entry.text ?? entry.key);
+        }
+    }
+    return map;
+}
+async function getRequestStatusMap(client) {
+    if (!requestStatusMap) {
+        requestStatusMap = await fetchDomainMap(client, 'rspm_request_status');
+    }
+    return requestStatusMap;
+}
+async function getProcessStatusMap(client) {
+    if (!processStatusMap) {
+        processStatusMap = await fetchDomainMap(client, 'rspm_process_status');
+    }
+    return processStatusMap;
+}
+function decodeStatus(map, code) {
+    const raw = code ?? '';
+    const text = map.get(raw);
+    return text ? `${text} (${raw})` : raw;
+}
+export async function bwListRequests(client, target, targetType = 'ADSO', storage = 'AQ,AX,AT', status = 'N,GG,GR,YG,RR,YR,RG,U,Y,X', top = 3, createdFrom) {
+    // top bounds the result set; each returned row triggers an expensive per-row
+    // backend enrichment, so createdfrom only helps by shrinking the result set.
+    let url = `/sap/bc/http/sap/bw4/v1/manage/requests` +
+        `?tlogo=${encodeURIComponent(targetType.toLowerCase())}` +
+        `&datatarget=${encodeURIComponent(target.toLowerCase())}` +
+        `&storage=${encodeURIComponent(storage)}`;
+    if (createdFrom) {
+        // Server-side lower time bound; the Cockpit drops latestrequests in this case.
+        url += `&createdfrom=${encodeURIComponent(createdFrom)}`;
+    }
+    else {
+        url += `&latestrequests=${top}`;
+    }
+    url += `&top=${top}` + `&status=${encodeURIComponent(status)}`;
+    const result = await client.rawGet(url, GET_HEADERS);
+    const requests = JSON.parse(result.body);
+    const statusMap = await getRequestStatusMap(client);
+    const processStatusMapList = await getProcessStatusMap(client);
+    const lines = [];
+    lines.push(`Requests of ${target.toUpperCase()} (${targetType.toUpperCase()}) — ${requests.length} shown`);
+    lines.push('');
+    if (requests.length === 0) {
+        lines.push('(no requests found)');
+        return lines.join('\n');
+    }
+    for (const req of requests) {
+        lines.push(`Request: ${req.requestTsnExternal ?? ''}`);
+        lines.push(`  Status:       ${decodeStatus(statusMap, req.requestStatus)}`);
+        lines.push(`  Last Process: ${decodeStatus(processStatusMapList, req.lastProcessStatus)}`);
+        if (req.lastAction)
+            lines.push(`  Last Action:  ${req.lastAction}`);
+        lines.push(`  Records:      ${req.records ?? ''}`);
+        lines.push(`  Timestamp:    ${req.lastTimeStamp ?? ''}`);
+        lines.push(`  User:         ${req.user?.fullName ?? ''}`);
+        lines.push(`  TSN:          ${req.requestTsn ?? ''}`);
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+export async function bwGetRequest(client, requestTsn, storage = 'AQ', format = 'text') {
+    const s = storage.toLowerCase();
+    const headerUrl = `/sap/bc/http/sap/bw4/v1/manage/requests/${encodeURIComponent(requestTsn)}/${s}`;
+    const dtpInfoUrl = `/sap/bc/http/sap/bw4/v1/manage/requests/${encodeURIComponent(requestTsn)}/${s}/datatransferprocessinformation`;
+    const processesUrl = `/sap/bc/http/sap/bw4/v1/manage/processes?request=${encodeURIComponent(requestTsn)}&storage=${s}`;
+    const logsUrl = `/sap/bc/http/sap/bw4/v1/manage/processes/${encodeURIComponent(requestTsn)}/logs?top=100&readMaximumNumberOfResults=true`;
+    const [headerRes, dtpInfoRes, processesRes, logsRes] = await Promise.all([
+        client.rawGet(headerUrl, GET_HEADERS),
+        client.rawGet(dtpInfoUrl, GET_HEADERS),
+        client.rawGet(processesUrl, GET_HEADERS),
+        client.rawGet(logsUrl, GET_HEADERS),
+    ]);
+    const header = JSON.parse(headerRes.body);
+    const dtpInfo = JSON.parse(dtpInfoRes.body);
+    const processes = JSON.parse(processesRes.body);
+    const logs = JSON.parse(logsRes.body);
+    if (format === 'raw') {
+        return JSON.stringify({ header, dtpInformation: dtpInfo, processes, logs }, null, 2);
+    }
+    const requestStatus = await getRequestStatusMap(client);
+    const processStatus = await getProcessStatusMap(client);
+    const lines = [];
+    // Section 1 — header
+    // Both the header request status and the last process status are shown: for some green
+    // inbound loads requestStatus lags at "Y" (in process) while lastProcessStatus already
+    // reads "G" (green). Surfacing both keeps a genuinely running request distinguishable
+    // from a finished one without remapping requestStatus.
+    lines.push(`Request: ${header.requestTsnExternal ?? requestTsn}`);
+    lines.push(`  Status:       ${decodeStatus(requestStatus, header.requestStatus)}`);
+    lines.push(`  Last Process: ${decodeStatus(processStatus, header.lastProcessStatus)}`);
+    lines.push(`  Last Action:  ${header.lastAction ?? ''}`);
+    lines.push(`  Tooltip:      ${header.statusTooltip ?? ''}`);
+    lines.push(`  Records:      ${header.records ?? ''}`);
+    lines.push(`  User:         ${header.user?.fullName ?? ''}`);
+    lines.push(`  Timestamp:    ${header.lastTimeStamp ?? ''}`);
+    // Section 2 — DTP information
+    lines.push('');
+    lines.push('── DTP Information ──');
+    lines.push(`  DTP:          ${dtpInfo.dataTransferProcess ?? ''}`);
+    lines.push(`  Description:  ${dtpInfo.dtpDescription ?? ''}`);
+    lines.push(`  Process Mode: ${dtpInfo.processModeDescription ?? ''}`);
+    lines.push(`  Start:        ${dtpInfo.requestStart ?? ''}`);
+    lines.push(`  Finish:       ${dtpInfo.requestFinish ?? ''}`);
+    lines.push(`  Duration:     ${dtpInfo.requestDuration ?? ''}`);
+    lines.push(`  Package Size: ${dtpInfo.packageSize ?? ''}`);
+    // Section 3 — process steps
+    lines.push('');
+    lines.push(`── Process Steps (${processes.length}) ──`);
+    for (const step of processes) {
+        lines.push(`  ${step.processTsnExternal ?? ''} — ${step.processTypeDescription ?? ''}`);
+        lines.push(`      Status:    ${decodeStatus(processStatus, step.processStatus)}`);
+        lines.push(`      Timestamp: ${step.timestamp ?? ''}`);
+    }
+    // Section 4 — message log
+    lines.push('');
+    lines.push(`── Message Log (${logs.length}) ──`);
+    for (const log of logs) {
+        lines.push(`  [${log.severity ?? ''}] ${log.message ?? ''}`);
+        if (log.longText && log.longText.length > 0) {
+            lines.push(`      ${log.longText}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * bw_activate_request — activate loaded data (DSO request activation).
+ *
+ * Moves a finished load from the Inbound Table into the active data table + change log. This is the
+ * runtime RSPM request activation under the BW4 manage API ("Aktivieren" in the load-request
+ * details) — NOT the modeling-object activation that bw_activate performs (different endpoint).
+ *
+ * Single POST to .../manage/requests/{tsn}/{storage}/activate with an empty body; the URL is
+ * self-contained and the default activates all previous loads up to this request.
+ *
+ * Runs in a fresh session (createClientFromEnv()) — like the DTP-activation and DTP-run tools —
+ * to avoid a stale shared-session buffer and cross-call session/CSRF collisions.
+ *
+ * Activation is asynchronous: a 200 means it was kicked off, not that it finished. Completion is
+ * monitored via bw_list_requests / bw_get_request.
+ */
+export async function bwActivateRequest(requestTsn, storage = 'AQ') {
+    const s = storage.toLowerCase();
+    const url = `/sap/bc/http/sap/bw4/v1/manage/requests/${encodeURIComponent(requestTsn)}/${s}/activate`;
+    const runClient = createClientFromEnv();
+    const csrfToken = await runClient.getCsrfToken();
+    await runClient.rawPost(url, '', {
+        'Content-Type': 'application/json',
+        'Accept': '*/*',
+        'x-csrf-token': csrfToken,
+    });
+    return JSON.stringify({
+        success: true,
+        request_tsn: requestTsn,
+        message: `Data activation started for request ${requestTsn} (storage ${storage.toUpperCase()}). ` +
+            `Activation runs asynchronously; monitor completion via bw_list_requests / bw_get_request.`,
+    });
+}

package/dist/tools/roles.js

@@ -0,0 +1,503 @@
+// ── XML helpers ───────────────────────────────────────────────────────────────
+function xmlDecode(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'");
+}
+function xmlEscape(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function parseAttrs(attrStr) {
+    const attrs = {};
+    const re = /(\w+)="([^"]*)"/g;
+    let m;
+    while ((m = re.exec(attrStr)) !== null) {
+        attrs[m[1]] = xmlDecode(m[2]);
+    }
+    return attrs;
+}
+// ── Recursive XML node parser ─────────────────────────────────────────────────
+function parseNodes(xml) {
+    const nodes = [];
+    let pos = 0;
+    while (pos < xml.length) {
+        const nodeStart = xml.indexOf('<node', pos);
+        if (nodeStart === -1)
+            break;
+        const tagEnd = xml.indexOf('>', nodeStart);
+        if (tagEnd === -1)
+            break;
+        const tagInner = xml.substring(nodeStart + 5, tagEnd);
+        const isSelfClosing = tagInner.trimEnd().endsWith('/');
+        const attrStr = isSelfClosing ? tagInner.trimEnd().slice(0, -1) : tagInner;
+        const attrs = parseAttrs(attrStr);
+        const node = {
+            nodeid: attrs['nodeid'] ?? '',
+            role: attrs['role'] ?? '',
+            name: attrs['name'] ?? '',
+            type: attrs['type'] ?? 'FOLDER',
+            txt: attrs['txt'] ?? '',
+            children: [],
+        };
+        if (attrs['attribKey'] !== undefined)
+            node.attribKey = attrs['attribKey'];
+        if (attrs['attribTxt'] !== undefined)
+            node.attribTxt = attrs['attribTxt'];
+        if (isSelfClosing) {
+            pos = tagEnd + 1;
+        }
+        else {
+            // Find the matching </node> tracking nesting depth
+            let depth = 1;
+            let searchPos = tagEnd + 1;
+            let closingPos = -1;
+            while (depth > 0 && searchPos < xml.length) {
+                const nextOpen = xml.indexOf('<node', searchPos);
+                const nextClose = xml.indexOf('</node>', searchPos);
+                if (nextClose === -1)
+                    break;
+                if (nextOpen !== -1 && nextOpen < nextClose) {
+                    const innerTagEnd = xml.indexOf('>', nextOpen);
+                    const innerTagInner = xml.substring(nextOpen + 5, innerTagEnd);
+                    if (!innerTagInner.trimEnd().endsWith('/')) {
+                        depth++;
+                    }
+                    searchPos = innerTagEnd + 1;
+                }
+                else {
+                    depth--;
+                    if (depth === 0) {
+                        closingPos = nextClose;
+                    }
+                    searchPos = nextClose + 7; // '</node>'.length === 7
+                }
+            }
+            if (closingPos !== -1) {
+                const childXml = xml.substring(tagEnd + 1, closingPos);
+                node.children = parseNodes(childXml);
+                pos = closingPos + 7;
+            }
+            else {
+                pos = tagEnd + 1;
+            }
+        }
+        nodes.push(node);
+    }
+    return nodes;
+}
+// ── Rendering ─────────────────────────────────────────────────────────────────
+function renderFolderChild(node, indent, lines) {
+    lines.push(`${indent}[FOLDER] ${node.txt} (nodeid: ${node.nodeid})`);
+    for (const child of node.children) {
+        renderFolderChild(child, indent + '  ', lines);
+    }
+}
+function renderTreeNode(node, indent, lines) {
+    if (node.type === 'ROLE') {
+        lines.push(`${indent}[ROLE] ${node.name} — ${node.txt}`);
+        lines.push(`${indent}  nodeid: ${node.nodeid}`);
+        for (const child of node.children) {
+            renderFolderChild(child, indent + '    ', lines);
+        }
+    }
+    else {
+        // Top-level FOLDER wrapper — show name (txt is empty at this level)
+        lines.push(`${indent}[FOLDER] ${node.name || node.txt}`);
+        for (const child of node.children) {
+            renderTreeNode(child, indent + '  ', lines);
+        }
+    }
+}
+// ── PUT body builders ─────────────────────────────────────────────────────────
+function buildFolderChildXml(node, indent) {
+    const lines = [];
+    if (node.children.length === 0) {
+        lines.push(`${indent}<node nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" ` +
+            `state="unchanged" type="${node.type}" txt="${xmlEscape(node.txt)}"/>`);
+    }
+    else {
+        lines.push(`${indent}<node nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" ` +
+            `state="unchanged" type="${node.type}" txt="${xmlEscape(node.txt)}">`);
+        for (const child of node.children) {
+            lines.push(...buildFolderChildXml(child, indent + '  '));
+        }
+        lines.push(`${indent}</node>`);
+    }
+    return lines;
+}
+function buildAddFolderBody(queryName, node) {
+    return [
+        `<?xml version="1.0" encoding="utf-8"?>`,
+        `<tree type="SAP_BW_QUERY" viewType="ancestors" refName="${xmlEscape(queryName)}">`,
+        `  <node nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" state="added" type="FOLDER" txt="${xmlEscape(node.txt)}">`,
+        `  </node>`,
+        `</tree>`,
+    ].join('\n');
+}
+function buildAddRoleBody(queryName, node) {
+    const lines = [
+        `<?xml version="1.0" encoding="utf-8"?>`,
+        `<tree type="SAP_BW_QUERY" viewType="ancestors" refName="${xmlEscape(queryName)}">`,
+        `  <node nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" state="added" type="ROLE" ` +
+            `txt="${xmlEscape(node.txt)}" name="${xmlEscape(node.name)}">`,
+    ];
+    for (const child of node.children) {
+        lines.push(...buildFolderChildXml(child, '    '));
+    }
+    lines.push(`  </node>`);
+    lines.push(`</tree>`);
+    return lines.join('\n');
+}
+function buildDeleteBody(queryName, node) {
+    const attribKey = xmlEscape(node.attribKey ?? '');
+    const attribTxt = xmlEscape(node.attribTxt ?? '');
+    const nodeAttrs = node.type === 'ROLE'
+        ? `nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" state="deleted" type="ROLE" ` +
+            `txt="${xmlEscape(node.txt)}" attribKey="${attribKey}" attribTxt="${attribTxt}" name="${xmlEscape(node.name)}"`
+        : `nodeid="${node.nodeid}" role="${xmlEscape(node.role)}" state="deleted" type="FOLDER" ` +
+            `txt="${xmlEscape(node.txt)}" attribKey="${attribKey}" attribTxt="${attribTxt}"`;
+    return [
+        `<?xml version="1.0" encoding="utf-8"?>`,
+        `<tree type="SAP_BW_QUERY" viewType="ancestors" refName="${xmlEscape(queryName)}">`,
+        `  <node ${nodeAttrs}>`,
+        `  </node>`,
+        `</tree>`,
+    ].join('\n');
+}
+// ── PUT response parser ───────────────────────────────────────────────────────
+function parsePutResponse(xml) {
+    // The response is an atom:feed; the entry-level title/summary carry the actual message.
+    const entryMatch = xml.match(/<atom:entry\b[^>]*>([\s\S]*?)<\/atom:entry>/);
+    const entryXml = entryMatch?.[1] ?? xml;
+    const summary = entryXml.match(/<atom:summary[^>]*>([^<]*)<\/atom:summary>/)?.[1] ?? '';
+    const title = entryXml.match(/<atom:title[^>]*>([^<]*)<\/atom:title>/)?.[1] ?? xml;
+    if (summary.includes('Fehler')) {
+        throw new Error(title);
+    }
+    return title;
+}
+// ── Internal fetch helpers ────────────────────────────────────────────────────
+async function fetchRolesTree(client) {
+    const { body } = await client.rawGet('/sap/bw/modeling/comp/roles?level=10&requestchk=true&readleaves=false', { Accept: 'application/xml', 'X-sap-adt-sessiontype': 'stateless' });
+    const treeMatch = body.match(/<tree\b[^>]*>([\s\S]*)<\/tree>/);
+    if (!treeMatch)
+        return [];
+    return parseNodes(treeMatch[1]);
+}
+async function fetchQueryAssignments(client, queryName) {
+    const { body } = await client.rawGet(`/sap/bw/modeling/comp/roles?type=SAP_BW_QUERY&ancof=${encodeURIComponent(queryName)}`, { Accept: 'application/xml', 'X-sap-adt-sessiontype': 'stateless' });
+    const treeAttrStr = body.match(/<tree\b([^>]*?)(?:\/>|>)/)?.[1] ?? '';
+    const treeAttrs = parseAttrs(treeAttrStr);
+    const refName = treeAttrs['refName'] ?? queryName;
+    const queryTxt = treeAttrs['txt'] ?? '';
+    // Self-closing or empty tree means not published
+    if (/<tree\b[^>]*\/>/.test(body)) {
+        return { refName, queryTxt, assignments: [] };
+    }
+    const treeMatch = body.match(/<tree\b[^>]*>([\s\S]*)<\/tree>/);
+    if (!treeMatch)
+        return { refName, queryTxt, assignments: [] };
+    const roleNodes = parseNodes(treeMatch[1]);
+    const assignments = roleNodes.map(rn => {
+        // The ancestor view returns a top-level FOLDER node when the query is assigned inside a
+        // subfolder. The role name is embedded in the `role` attribute ("ROLENAME   ORIGINID").
+        // When assigned at role level, a ROLE node is returned with `name` set directly.
+        if (rn.type === 'FOLDER') {
+            return {
+                roleName: rn.role.split(/\s+/)[0],
+                roleNodeid: '',
+                roleRole: '',
+                roleTxt: '',
+                attribKey: rn.attribKey ?? '',
+                attribTxt: rn.attribTxt ?? '',
+                folder: { nodeid: rn.nodeid, role: rn.role, txt: rn.txt },
+            };
+        }
+        const a = {
+            roleName: rn.name || rn.role.split(/\s+/)[0],
+            roleNodeid: rn.nodeid,
+            roleRole: rn.role,
+            roleTxt: rn.txt,
+            attribKey: rn.attribKey ?? '',
+            attribTxt: rn.attribTxt ?? '',
+        };
+        if (rn.children.length > 0) {
+            const f = rn.children[0];
+            a.folder = { nodeid: f.nodeid, role: f.role, txt: f.txt };
+        }
+        return a;
+    });
+    return { refName, queryTxt, assignments };
+}
+function parseLeaves(xml) {
+    const leaves = [];
+    const re = /<leaf\s([^>]*?)\/?>/g;
+    let m;
+    while ((m = re.exec(xml)) !== null) {
+        const attrs = parseAttrs(m[1]);
+        leaves.push({
+            nodeid: attrs['nodeid'] ?? '',
+            name: attrs['name'] ?? '',
+            txt: attrs['txt'] ?? '',
+            objectType: attrs['objectType'] ?? '',
+            objectSubType: attrs['objectSubType'] ?? '',
+            infoprov: attrs['infoprov'] ?? '',
+            guid: attrs['guid'] ?? '',
+            responsible: attrs['responsible'] ?? '',
+            timestamp: attrs['timestamp'] ?? '',
+        });
+    }
+    return leaves;
+}
+function parseRolesWithLeaves(xml) {
+    const result = [];
+    function walk(content) {
+        let pos = 0;
+        while (pos < content.length) {
+            const nodeStart = content.indexOf('<node', pos);
+            if (nodeStart === -1)
+                break;
+            const tagEnd = content.indexOf('>', nodeStart);
+            if (tagEnd === -1)
+                break;
+            const tagInner = content.substring(nodeStart + 5, tagEnd);
+            const isSelfClosing = tagInner.trimEnd().endsWith('/');
+            const attrStr = isSelfClosing ? tagInner.trimEnd().slice(0, -1) : tagInner;
+            const attrs = parseAttrs(attrStr);
+            if (isSelfClosing) {
+                pos = tagEnd + 1;
+                continue;
+            }
+            let depth = 1;
+            let searchPos = tagEnd + 1;
+            let closingPos = -1;
+            while (depth > 0 && searchPos < content.length) {
+                const nextOpen = content.indexOf('<node', searchPos);
+                const nextClose = content.indexOf('</node>', searchPos);
+                if (nextClose === -1)
+                    break;
+                if (nextOpen !== -1 && nextOpen < nextClose) {
+                    const innerTagEnd = content.indexOf('>', nextOpen);
+                    const innerTagInner = content.substring(nextOpen + 5, innerTagEnd);
+                    if (!innerTagInner.trimEnd().endsWith('/'))
+                        depth++;
+                    searchPos = innerTagEnd + 1;
+                }
+                else {
+                    depth--;
+                    if (depth === 0)
+                        closingPos = nextClose;
+                    searchPos = nextClose + 7;
+                }
+            }
+            const childContent = closingPos !== -1 ? content.substring(tagEnd + 1, closingPos) : '';
+            if (attrs['type'] === 'ROLE') {
+                const leaves = parseLeaves(childContent);
+                if (leaves.length > 0) {
+                    result.push({ roleName: attrs['name'] ?? '', roleTxt: attrs['txt'] ?? '', leaves });
+                }
+            }
+            else {
+                walk(childContent);
+            }
+            pos = closingPos !== -1 ? closingPos + 7 : tagEnd + 1;
+        }
+    }
+    walk(xml);
+    return result;
+}
+// ── Exported functions ────────────────────────────────────────────────────────
+export async function bwGetRoles(client, roleFilter) {
+    const { body } = await client.rawGet('/sap/bw/modeling/comp/roles?level=10&requestchk=true&readleaves=false', { Accept: 'application/xml', 'X-sap-adt-sessiontype': 'stateless' });
+    const treeMatch = body.match(/<tree\b[^>]*>([\s\S]*)<\/tree>/);
+    if (!treeMatch)
+        return 'No role tree found.';
+    const topNodes = parseNodes(treeMatch[1]);
+    function countRoles(nodes) {
+        let count = 0;
+        for (const n of nodes) {
+            if (n.type === 'ROLE')
+                count++;
+            count += countRoles(n.children);
+        }
+        return count;
+    }
+    function filterNodes(nodes) {
+        if (!roleFilter)
+            return nodes;
+        return nodes.flatMap(n => {
+            if (n.type === 'ROLE') {
+                return n.name.startsWith(roleFilter) ? [n] : [];
+            }
+            // FOLDER: keep as structural container if it has matching descendants
+            const filteredChildren = filterNodes(n.children);
+            return filteredChildren.length > 0 ? [{ ...n, children: filteredChildren }] : [];
+        });
+    }
+    const totalRoles = countRoles(topNodes);
+    const filteredNodes = filterNodes(topNodes);
+    const lines = [
+        'BW Query Role Tree',
+        '==================',
+        `Total roles: ${totalRoles}`,
+        '',
+    ];
+    for (const node of filteredNodes) {
+        renderTreeNode(node, '', lines);
+    }
+    return lines.join('\n');
+}
+export async function bwGetQueryRoles(client, queryName) {
+    const { refName, queryTxt, assignments } = await fetchQueryAssignments(client, queryName.toUpperCase());
+    if (assignments.length === 0) {
+        return `Query ${refName} is not published in any role.`;
+    }
+    const lines = [
+        `Query: ${refName}${queryTxt ? ` — ${queryTxt}` : ''}`,
+        '',
+        `Published in ${assignments.length} role(s):`,
+    ];
+    for (const a of assignments) {
+        const roleDesc = a.roleTxt ? ` — ${a.roleTxt}` : '';
+        lines.push(`  [ROLE] ${a.roleName}${roleDesc}`);
+        if (a.folder) {
+            lines.push(`    Folder: ${a.folder.txt}`);
+        }
+    }
+    return lines.join('\n');
+}
+export async function bwSetQueryRoles(client, queryName, action, targetName, targetType, parentRoleName) {
+    const qName = queryName.toUpperCase();
+    const putUrl = `/sap/bw/modeling/comp/roles?type=SAP_BW_QUERY&ancof=${encodeURIComponent(qName)}`;
+    let putBody;
+    if (action === 'add') {
+        const tree = await fetchRolesTree(client);
+        if (targetType === 'role') {
+            function findRole(nodes) {
+                for (const n of nodes) {
+                    if (n.type === 'ROLE' && n.name === targetName)
+                        return n;
+                    const found = findRole(n.children);
+                    if (found)
+                        return found;
+                }
+                return undefined;
+            }
+            const roleNode = findRole(tree);
+            if (!roleNode)
+                throw new Error(`Role "${targetName}" not found in role tree.`);
+            putBody = buildAddRoleBody(qName, roleNode);
+        }
+        else {
+            if (!parentRoleName)
+                throw new Error('parent_role_name is required when target_type is "folder".');
+            function findParentRole(nodes) {
+                for (const n of nodes) {
+                    if (n.type === 'ROLE' && n.name === parentRoleName)
+                        return n;
+                    const found = findParentRole(n.children);
+                    if (found)
+                        return found;
+                }
+                return undefined;
+            }
+            const parentRole = findParentRole(tree);
+            if (!parentRole)
+                throw new Error(`Role "${parentRoleName}" not found in role tree.`);
+            function findFolder(nodes) {
+                for (const n of nodes) {
+                    if (n.type === 'FOLDER' && n.txt === targetName)
+                        return n;
+                    const found = findFolder(n.children);
+                    if (found)
+                        return found;
+                }
+                return undefined;
+            }
+            const folderNode = findFolder(parentRole.children);
+            if (!folderNode)
+                throw new Error(`Folder "${targetName}" not found in role "${parentRoleName}".`);
+            putBody = buildAddFolderBody(qName, folderNode);
+        }
+    }
+    else {
+        // action === 'remove'
+        const { assignments } = await fetchQueryAssignments(client, qName);
+        if (assignments.length === 0)
+            throw new Error(`Query "${qName}" is not published in any role.`);
+        if (targetType === 'role') {
+            const a = assignments.find(x => x.roleName === targetName);
+            if (!a)
+                throw new Error(`Query "${qName}" is not published in role "${targetName}".`);
+            putBody = buildDeleteBody(qName, {
+                nodeid: a.roleNodeid,
+                role: a.roleRole,
+                name: a.roleName,
+                type: 'ROLE',
+                txt: a.roleTxt,
+                attribKey: a.attribKey,
+                attribTxt: a.attribTxt,
+                children: [],
+            });
+        }
+        else {
+            if (!parentRoleName)
+                throw new Error('parent_role_name is required when target_type is "folder".');
+            const a = assignments.find(x => x.roleName === parentRoleName && x.folder?.txt === targetName);
+            if (!a || !a.folder)
+                throw new Error(`Query "${qName}" is not published in folder "${targetName}" of role "${parentRoleName}".`);
+            putBody = buildDeleteBody(qName, {
+                nodeid: a.folder.nodeid,
+                role: a.folder.role,
+                name: '',
+                type: 'FOLDER',
+                txt: a.folder.txt,
+                attribKey: a.attribKey,
+                attribTxt: a.attribTxt,
+                children: [],
+            });
+        }
+    }
+    const csrfToken = await client.getCsrfToken();
+    const { body: putResponse } = await client.rawPut(putUrl, putBody, {
+        'Content-Type': 'application/xml',
+        'X-sap-adt-sessiontype': 'stateless',
+        'X-CSRF-Token': csrfToken,
+    });
+    return parsePutResponse(putResponse);
+}
+export async function bwGetRoleQueries(client, roleName) {
+    const { body } = await client.rawGet('/sap/bw/modeling/comp/roles?level=10&requestchk=true&readleaves=true', { Accept: 'application/xml', 'X-sap-adt-sessiontype': 'stateless' });
+    const treeMatch = body.match(/<tree\b[^>]*>([\s\S]*)<\/tree>/);
+    if (!treeMatch)
+        return 'No role tree found.';
+    const rolesWithLeaves = parseRolesWithLeaves(treeMatch[1]);
+    const filtered = roleName
+        ? rolesWithLeaves.filter(r => r.roleName === roleName)
+        : rolesWithLeaves;
+    if (filtered.length === 0) {
+        return roleName
+            ? `No published objects found in role "${roleName}".`
+            : 'No published objects found in any role.';
+    }
+    const lines = [];
+    let total = 0;
+    for (const r of filtered) {
+        lines.push(`[ROLE] ${r.roleName} — ${r.roleTxt}`);
+        for (const leaf of r.leaves) {
+            const label = leaf.txt && leaf.txt !== leaf.name ? `${leaf.name} — ${leaf.txt}` : leaf.name;
+            lines.push(`  ${label} (${leaf.objectType}/${leaf.objectSubType}, InfoProv: ${leaf.infoprov})`);
+            total++;
+        }
+        lines.push('');
+    }
+    lines.unshift(`Total published objects: ${total}`, '');
+    return lines.join('\n');
+}