@mseep/bw-modeling-mcp 0.8.0

package/dist/tools/infosource.js

@@ -0,0 +1,225 @@
+const TRCS_MEDIA = 'application/vnd.sap.bw.modeling.trcs-v1_0_0+xml';
+// ── bwGetInfosource ───────────────────────────────────────────────────────────
+/**
+ * bw_get_infosource — read the structure of an InfoSource (TRCS).
+ *
+ * GET /sap/bw/modeling/trcs/{name}/m
+ */
+export async function bwGetInfosource(client, name) {
+    const nameLower = name.toLowerCase();
+    const result = await client.get(`/sap/bw/modeling/trcs/${nameLower}/m`, TRCS_MEDIA);
+    const xml = result.body;
+    // Root attributes
+    const rootName = (xml.match(/trcs:infoSource[^>]+\bname="([^"]+)"/) ?? [])[1] ?? name.toUpperCase();
+    const aggregationAttr = (xml.match(/trcs:infoSource[^>]+\baggregation="([^"]+)"/) ?? [])[1];
+    const aggregation = aggregationAttr === 'true';
+    // endUserTexts label (top-level)
+    const labelMatch = xml.match(/^[\s\S]*?<endUserTexts label="([^"]*)"/);
+    const label = labelMatch ? labelMatch[1] : '';
+    // tlogoProperties
+    const tlogoPart = (xml.match(/<tlogoProperties([^>]*)>/) ?? [])[1] ?? '';
+    const description = (tlogoPart.match(/adtcore:description="([^"]*)"/) ?? [])[1] ?? '';
+    const objectStatus = (tlogoPart.match(/adtcore:version="([^"]*)"/) ?? [])[1] ?? '';
+    // <infoArea>
+    const infoArea = (xml.match(/<infoArea>([^<]*)<\/infoArea>/) ?? [])[1] ?? '';
+    // Collect keyElement names: #///NAME → NAME
+    const keyElements = new Set();
+    const keyRe = /<keyElement>#\/\/\/([^<]+)<\/keyElement>/g;
+    let km;
+    while ((km = keyRe.exec(xml)) !== null) {
+        keyElements.add(km[1].toUpperCase());
+    }
+    // Parse <element> blocks
+    const fields = [];
+    const elemRe = /<element\b([\s\S]*?)<\/element>/g;
+    let em;
+    while ((em = elemRe.exec(xml)) !== null) {
+        const block = em[1];
+        const fieldName = (block.match(/\bname="([^"]+)"/) ?? [])[1];
+        if (!fieldName)
+            continue;
+        const iObjName = (block.match(/\binfoObjectName="([^"]+)"/) ?? [])[1];
+        const fieldLabel = (block.match(/<endUserTexts label="([^"]*)"/) ??
+            block.match(/<descriptions label="([^"]*)"/) ?? [])[1] ?? '';
+        const dataType = (block.match(/<inlineType\b[^>]*\bname="([^"]+)"/) ?? [])[1] ?? '';
+        const lengthStr = (block.match(/<inlineType\b[^>]*\blength="([^"]+)"/) ?? [])[1];
+        const aggrBehav = (block.match(/\baggregationBehavior="([^"]+)"/) ?? [])[1];
+        const field = {
+            name: fieldName,
+            label: fieldLabel,
+            data_type: dataType,
+            is_key: keyElements.has(fieldName.toUpperCase()),
+        };
+        if (iObjName)
+            field['infoobject_name'] = iObjName;
+        if (lengthStr !== undefined)
+            field['length'] = Number(lengthStr);
+        if (aggrBehav)
+            field['aggregation_behavior'] = aggrBehav;
+        fields.push(field);
+    }
+    return JSON.stringify({
+        name: rootName,
+        label,
+        description,
+        info_area: infoArea,
+        object_status: objectStatus,
+        aggregation,
+        fields,
+    }, null, 2);
+}
+function buildElement(field) {
+    const name = field.name.toUpperCase();
+    const aggr = field.aggregationBehavior ?? 'NONE';
+    if (field.infoObjectName) {
+        const iobj = field.infoObjectName.toUpperCase();
+        return (`  <element xsi:type="BwCore:BwElement"\n` +
+            `    name="${name}"\n` +
+            `    keep="false"\n` +
+            `    aggregationBehavior="${aggr}"\n` +
+            `    attributeHierarchyDefaultMember=""\n` +
+            `    infoObjectName="${iobj}"\n` +
+            `    displayFolder="">\n` +
+            `    <endUserTexts label="${field.label}"/>\n` +
+            `    <inlineType name="${field.type}" length="${field.length}" globalElementName="${iobj}"/>\n` +
+            `    <fixedCurrency></fixedCurrency>\n` +
+            `    <fixedUnit></fixedUnit>\n` +
+            `    <associationType>1</associationType>\n` +
+            `  </element>`);
+    }
+    else {
+        return (`  <element xsi:type="BwCore:BwElement"\n` +
+            `    name="${name}"\n` +
+            `    aggregationBehavior="${aggr}"\n` +
+            `    conversionRoutine="">\n` +
+            `    <inlineType name="${field.type}" length="${field.length}" precision="0" scale="0" semanticType="empty"/>\n` +
+            `    <localProperties xsi:type="BwCore:LocalCharacteristicProperties">\n` +
+            `      <descriptions label="${field.label}"/>\n` +
+            `    </localProperties>\n` +
+            `  </element>`);
+    }
+}
+// ── bw_create_infosource ──────────────────────────────────────────────────────
+/**
+ * bw_create_infosource — create a new InfoSource (TRCS) shell.
+ *
+ * Optionally copies fields from an existing object (aDSO, CompositeProvider,
+ * DataSource, or InfoObject) via copyFrom* parameters.
+ *
+ * Workflow: Lock (CREA) → POST → Unlock
+ * After creation the InfoSource is inactive — call bw_activate with object_type "trcs".
+ */
+export async function bwCreateInfosource(client, name, description, infoArea, pkg = '$TMP', copyFromObjectName, copyFromObjectType, copyFromObjectSubType, copyFromSourceSystem) {
+    const nameUpper = name.toUpperCase();
+    const infoAreaUpper = infoArea.toUpperCase();
+    const lockHandle = await client.lock('trcs', name, { 'activity_context': 'CREA' });
+    // Build URL — add copyFrom params before lockHandle when provided
+    let url = `/sap/bw/modeling/trcs/${name.toLowerCase()}`;
+    const qs = [];
+    if (copyFromObjectType && copyFromObjectName) {
+        let encodedName = copyFromObjectName;
+        if (copyFromObjectType === 'RSDS' && copyFromSourceSystem) {
+            encodedName = copyFromObjectName.padEnd(30) + copyFromSourceSystem.padEnd(10);
+        }
+        qs.push(`copyFromObjectName=${encodeURIComponent(encodedName)}`);
+        qs.push(`copyFromObjectType=${encodeURIComponent(copyFromObjectType)}`);
+        if (copyFromObjectSubType) {
+            qs.push(`copyFromObjectSubType=${encodeURIComponent(copyFromObjectSubType)}`);
+        }
+    }
+    qs.push(`lockHandle=${lockHandle}`);
+    url += '?' + qs.join('&');
+    const language = process.env.BW_LANGUAGE ?? 'DE';
+    const body = `<?xml version="1.0" encoding="UTF-8"?>\n` +
+        `<trcs:infoSource\n` +
+        `  xmlns:adtcore="http://www.sap.com/adt/core"\n` +
+        `  xmlns:trcs="http://www.sap.com/bw/modeling/trcs.ecore"\n` +
+        `  name="${nameUpper}">\n` +
+        `  <endUserTexts label="${description}"/>\n` +
+        `  <tlogoProperties\n` +
+        `    adtcore:language="${language}"\n` +
+        `    adtcore:name="${nameUpper}"\n` +
+        `    adtcore:type="TRCS"\n` +
+        `    adtcore:masterLanguage="${language}">\n` +
+        `    <infoArea>${infoAreaUpper}</infoArea>\n` +
+        `  </tlogoProperties>\n` +
+        `</trcs:infoSource>`;
+    try {
+        await client.postWithCsrf(url, body, `application/xml, ${TRCS_MEDIA}`, {
+            'Development-Class': pkg,
+            Accept: TRCS_MEDIA,
+        });
+    }
+    catch (err) {
+        await client.unlock('trcs', name).catch(() => { });
+        throw err;
+    }
+    await client.unlock('trcs', name);
+    const fromParts = [];
+    if (copyFromObjectType && copyFromObjectName) {
+        fromParts.push(` from ${copyFromObjectType} ${copyFromObjectName.toUpperCase()}`);
+        if (copyFromObjectSubType)
+            fromParts.push(` (${copyFromObjectSubType})`);
+    }
+    return JSON.stringify({
+        success: true,
+        message: `InfoSource ${nameUpper} created${fromParts.join('')} in package ${pkg}. Call bw_activate to activate.`,
+        infosource_name: nameUpper,
+        object_type: 'trcs',
+    });
+}
+// ── bw_update_infosource ──────────────────────────────────────────────────────
+/**
+ * bw_update_infosource — replace the field list of an InfoSource.
+ *
+ * Workflow: Lock → GET full XML → replace element/keyElement sections → PUT
+ * tlogoProperties are passed through unchanged.
+ * Returns lock_handle for bw_activate.
+ */
+export async function bwUpdateInfosource(client, name, description, fields, transport) {
+    const nameUpper = name.toUpperCase();
+    const trcsPath = `/sap/bw/modeling/trcs/${name.toLowerCase()}/m`;
+    // 1. Lock (no activity_context = update mode)
+    const lockHandle = await client.lock('trcs', name);
+    // 2. GET current XML
+    const getResult = await client.get(trcsPath, TRCS_MEDIA);
+    const timestamp = getResult.headers['timestamp'] ?? getResult.headers['TIMESTAMP'];
+    let xml = getResult.body;
+    // 3. Update description
+    if (description !== undefined) {
+        xml = xml.replace(/<endUserTexts label="[^"]*"\s*\/>/, `<endUserTexts label="${description}"/>`);
+    }
+    // 4. Replace elements and keyElements
+    if (fields !== undefined) {
+        // Strip all existing <element> blocks (may span multiple lines)
+        xml = xml.replace(/[ \t]*<element\b[\s\S]*?<\/element>\n?/g, '');
+        // Strip all existing <keyElement> entries
+        xml = xml.replace(/[ \t]*<keyElement>[^<]*<\/keyElement>\n?/g, '');
+        const elementBlocks = fields.map(buildElement);
+        const keyBlocks = fields
+            .filter((f) => f.isKey)
+            .map((f) => `  <keyElement>#///${f.name.toUpperCase()}</keyElement>`);
+        const insertBlock = [...elementBlocks, ...keyBlocks].join('\n') + '\n';
+        if (xml.includes('<tlogoProperties')) {
+            xml = xml.replace('<tlogoProperties', insertBlock + '  <tlogoProperties');
+        }
+        else {
+            xml = xml.replace('</trcs:infoSource>', insertBlock + '</trcs:infoSource>');
+        }
+    }
+    // 5. PUT
+    try {
+        await client.put('trcs', name, lockHandle, xml, timestamp, transport);
+    }
+    catch (err) {
+        await client.unlock('trcs', name).catch(() => { });
+        throw err;
+    }
+    return JSON.stringify({
+        success: true,
+        message: `InfoSource ${nameUpper} updated. Call bw_activate to activate.`,
+        lock_handle: lockHandle,
+        infosource_name: nameUpper,
+        object_type: 'trcs',
+    });
+}

package/dist/tools/processchain.js

@@ -0,0 +1,154 @@
+const ACCEPT = 'application/vnd.sap.bw4.modeling.processchain-v1_0_0+json';
+async function fetchVariantDetail(client, processType, variantName) {
+    const NO_DETAIL_TYPES = new Set(['OR', 'AND', 'EXOR', 'CHAIN', 'DTP_LOAD', 'DTP_ADSO']);
+    if (NO_DETAIL_TYPES.has(processType.toUpperCase()))
+        return null;
+    try {
+        const url = `/sap/bw4/v1/modeling/processtypes/${processType.toLowerCase()}/variants/${variantName.toLowerCase()}/m`;
+        const result = await client.rawGet(url, { Accept: '*/*' });
+        if (result.body.trim().startsWith('<'))
+            return null;
+        const parsed = JSON.parse(result.body);
+        const detail = parsed.oDetail;
+        if (!detail || (typeof detail === 'string' && detail.trim() === '') || (typeof detail === 'object' && Object.keys(detail).length === 0))
+            return null;
+        return JSON.stringify(detail, null, 2);
+    }
+    catch {
+        return null;
+    }
+}
+export async function bwGetProcessChain(client, chainName, format = 'text', includeVariantDetails = true) {
+    const url = `/sap/bw/modeling/rspc/${encodeURIComponent(chainName.toLowerCase())}/m`;
+    const result = await client.rawGet(url, { Accept: ACCEPT });
+    const parsed = JSON.parse(result.body);
+    if (format === 'raw') {
+        return JSON.stringify(parsed, null, 2);
+    }
+    const variantDetailMap = {};
+    if (format === 'text' && includeVariantDetails) {
+        for (const node of parsed.aNode ?? []) {
+            const type = node.sProcessType;
+            const variant = node.sProcessVariant;
+            if (type && variant) {
+                const detail = await fetchVariantDetail(client, type, variant);
+                if (detail)
+                    variantDetailMap[variant] = detail;
+            }
+        }
+    }
+    return renderText(parsed, variantDetailMap);
+}
+function renderText(pc, variantDetailMap = {}) {
+    const lines = [];
+    const header = pc.oHeader ?? {};
+    const sched = header.oSchedulingAttributes ?? {};
+    const mon = header.oMonitoringAttributes ?? {};
+    const nodes = pc.aNode ?? [];
+    const edges = pc.aEdge ?? [];
+    const variants = pc.aInlineVariant ?? [];
+    // Section 1 — header
+    lines.push(`Process Chain: ${header.sProcessChainId ?? ''}`);
+    lines.push(`Description:   ${header.sDescription ?? ''}`);
+    lines.push(`Status:        ${header.sObjectStatus ?? ''} / Version: ${header.sObjectVersion ?? ''}`);
+    lines.push(`InfoArea:      ${header.sLocation ?? ''} — ${header.sLocationDescription ?? ''}`);
+    lines.push(`Active:        ${header.bActive ?? false}`);
+    // Section 2 — Scheduling
+    lines.push('');
+    lines.push('── Scheduling ──');
+    lines.push(`  Job Priority:  ${sched.sJobPriority ?? ''}  (A=high B=normal C=low)`);
+    lines.push(`  Job Owner:     ${sched.oJobOwner?.sJobOwner || '(not set)'}`);
+    lines.push(`  Server:        ${sched.sExecutionServer || '(not set)'}`);
+    lines.push(`  Streaming:     ${sched.bStreaming ?? false}`);
+    // Section 3 — Monitoring
+    lines.push('');
+    lines.push('── Monitoring ──');
+    lines.push(`  Auto-Monitored:     ${mon.bAutoMonitored ?? false}`);
+    lines.push(`  Error Notification: ${mon.bErrorNotification ?? false}`);
+    lines.push(`  Keep-Alive:         ${mon.bKeepAlive ?? false}`);
+    lines.push(`  Auto-Reset:         ${mon.bAutoResetFailures ?? false}`);
+    // Section 4 — Steps
+    lines.push('');
+    lines.push(`── Steps (${nodes.length}) ──`);
+    nodes.forEach((node, idx) => {
+        const variantLabel = node.sVariantDescription || node.sProcessVariant || '';
+        lines.push(`  [${idx}] ${node.sTypeDescription ?? ''} — ${variantLabel}`);
+        lines.push(`      Type:    ${node.sProcessType ?? ''}`);
+        lines.push(`      Variant: ${node.sProcessVariant ?? ''}`);
+        lines.push(`      Status:  ${node.sStatus || 'neutral'}`);
+        lines.push(`      Skipped: ${node.bSkipped ?? false}`);
+        if (node.bIsReference === true) {
+            lines.push(`      Sub-Chain: ${node.sProcessVariant ?? ''}  (referenced)`);
+        }
+        for (const d of node.aDetail ?? []) {
+            if (d.sValue && d.sValue.length > 0) {
+                lines.push(`      ${d.sName ?? ''}: ${d.sValue}`);
+            }
+        }
+        if (node.sProcessType === 'DECISION') {
+            const branches = (node.aSocket ?? []).filter((s) => !(s.sSubStatus === '00' && s.sStatus === 'negative'));
+            if (branches.length > 0) {
+                lines.push(`      Branches:`);
+                for (const b of branches) {
+                    lines.push(`        [${b.sSubStatus ?? ''}] ${b.sDescription ?? ''}  (status: ${b.sStatus ?? ''})`);
+                }
+            }
+        }
+        if (node.sProcessType === 'OR') {
+            lines.push(`      (join node — merges multiple incoming branches)`);
+        }
+        const detailJson = variantDetailMap[node.sProcessVariant ?? ''];
+        if (detailJson) {
+            lines.push(`      ── Variant Detail ──`);
+            for (const line of detailJson.split('\n')) {
+                lines.push(`      ${line}`);
+            }
+        }
+    });
+    // Section 5 — Dependencies
+    lines.push('');
+    lines.push(`── Dependencies (${edges.length}) ──`);
+    for (const edge of edges) {
+        const source = nodes[edge.iNodeIndexFrom];
+        const target = nodes[edge.iNodeIndexTo];
+        const sourceType = source?.sProcessType ?? '?';
+        const targetType = target?.sProcessType ?? '?';
+        let condition;
+        if (edge.sSubStatus && edge.sSubStatus !== '00') {
+            const socket = source?.aSocket?.find((s) => s.sSubStatus === edge.sSubStatus);
+            condition = socket?.sDescription || edge.sStatus || '';
+        }
+        else {
+            condition = edge.sStatus || '';
+        }
+        lines.push(`  Step ${edge.iNodeIndexFrom} (${sourceType}) → Step ${edge.iNodeIndexTo} (${targetType})`);
+        lines.push(`      Condition: ${condition}  Strength: ${edge.sStrength ?? ''}`);
+    }
+    // Section 6 — Variants
+    lines.push('');
+    lines.push(`── Variants (${variants.length}) ──`);
+    for (const v of variants) {
+        const keys = Object.keys(v);
+        const isStub = keys.length === 1 && keys[0] === 'sProcessVariant';
+        if (isStub) {
+            lines.push(`  ${v.sProcessVariant ?? ''}  (no detail — auto-generated variant)`);
+            continue;
+        }
+        lines.push(`  ${v.sProcessVariant ?? ''}  (active: ${v.bActive ?? false})`);
+        lines.push(`      ${v.sVariantDescription || '(no description)'}`);
+        const detail = v.oDetail;
+        if (detail) {
+            if (detail.PROGRAM && detail.PROGRAM.length >= 1) {
+                const p = detail.PROGRAM[0];
+                lines.push(`      ABAP Program: ${p.key ?? ''}  Package: ${p.row?.package || '(unknown)'}`);
+            }
+            if (detail.eventid && detail.eventid.length >= 1) {
+                lines.push(`      Trigger Event: ${detail.eventid[0].key ?? ''}  Param: ${detail.eventparm ?? ''}`);
+            }
+            if (detail.startdttyp !== undefined) {
+                lines.push(`      Start Type: ${detail.startdttyp}  (E=event I=immediate P=periodic)`);
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/tools/processvariant.js

@@ -0,0 +1,49 @@
+export async function bwGetProcessVariant(client, processType, variantName, format = 'text') {
+    const url = `/sap/bw4/v1/modeling/processtypes/${encodeURIComponent(processType.toLowerCase())}/variants/${encodeURIComponent(variantName.toLowerCase())}/m`;
+    const result = await client.rawGet(url, { Accept: 'application/json' });
+    const parsed = JSON.parse(result.body);
+    if (format === 'raw') {
+        return JSON.stringify(parsed, null, 2);
+    }
+    return renderText(parsed, processType, variantName);
+}
+function renderText(pv, processType, variantName) {
+    const lines = [];
+    lines.push(`Process Variant: ${variantName.toUpperCase()}`);
+    lines.push(`Type:            ${processType.toUpperCase()}`);
+    lines.push(`Description:     ${pv.sVariantDescription || '(none)'}`);
+    lines.push(`Active:          ${pv.bActive ?? false}`);
+    lines.push('');
+    lines.push('── Detail ──');
+    const detail = pv.oDetail;
+    const detailEmpty = detail === undefined ||
+        detail === null ||
+        (typeof detail === 'string' && detail.length === 0);
+    if (detailEmpty) {
+        lines.push('  (no detail available)');
+    }
+    else {
+        const indented = JSON.stringify(detail, null, 2)
+            .split('\n')
+            .map((l) => `  ${l}`)
+            .join('\n');
+        lines.push(indented);
+    }
+    const sockets = pv.aSocket ?? [];
+    if (sockets.length > 0) {
+        lines.push('');
+        lines.push('── Sockets ──');
+        for (const s of sockets) {
+            lines.push(`  [${s.sSubStatus ?? ''}] ${s.sStatus ?? ''} — ${s.sDescription ?? ''}`);
+        }
+    }
+    const options = (pv.aExecutionOption ?? []).filter((o) => o.name && o.name.length > 0);
+    if (options.length > 0) {
+        lines.push('');
+        lines.push('── Execution Options ──');
+        for (const o of options) {
+            lines.push(`  [${o.name}] ${o.description ?? ''}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/tools/push.js

@@ -0,0 +1,100 @@
+import axios from 'axios';
+import https from 'https';
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+function getEnv(key) {
+    const val = process.env[key];
+    if (!val)
+        throw new Error(`Environment variable ${key} is not set`);
+    return val;
+}
+function buildAuth() {
+    const user = getEnv('BW_USER');
+    const pass = getEnv('BW_PASSWORD');
+    return 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64');
+}
+function pushBase(adsoName) {
+    const baseUrl = getEnv('BW_URL').replace(/\/$/, '');
+    return `${baseUrl}/sap/bw4/v1/push/dataStores/${adsoName.toLowerCase()}`;
+}
+/**
+ * bw_push_data — push records into an aDSO write-interface inbound table.
+ *
+ * Flow (One Step):
+ *   1. GET /requests with x-csrf-token: Fetch → extract token + session cookies
+ *   2. POST /dataSend with JSON array body → expect HTTP 204
+ */
+export async function bwPushData(adsoName, records, mode = 'one_step') {
+    const base = pushBase(adsoName);
+    const auth = buildAuth();
+    // Step 1: fetch CSRF token and session cookies
+    const csrfRes = await axios.get(`${base}/requests`, {
+        httpsAgent,
+        headers: {
+            'Authorization': auth,
+            'x-csrf-token': 'Fetch',
+        },
+        validateStatus: () => true,
+    });
+    const csrfToken = csrfRes.headers['x-csrf-token'];
+    if (!csrfToken || csrfToken.toLowerCase() === 'required') {
+        throw new Error(`Failed to fetch CSRF token. HTTP ${csrfRes.status}: ${csrfRes.data}`);
+    }
+    // Extract session cookies from set-cookie header
+    const rawCookies = Array.isArray(csrfRes.headers['set-cookie'])
+        ? csrfRes.headers['set-cookie']
+        : csrfRes.headers['set-cookie'] ? [csrfRes.headers['set-cookie']] : [];
+    const cookieParts = rawCookies
+        .map((c) => c.split(';')[0].trim())
+        .filter(Boolean);
+    const cookieHeader = cookieParts.join('; ');
+    // Step 2: POST dataSend
+    const sendUrl = mode === 'messaging'
+        ? `${base}/dataSend?request=MESSAGING`
+        : `${base}/dataSend`;
+    const sendRes = await axios.post(sendUrl, records, {
+        httpsAgent,
+        headers: {
+            'Authorization': auth,
+            'Content-Type': 'application/json',
+            'x-csrf-token': csrfToken,
+            ...(cookieHeader ? { 'Cookie': cookieHeader } : {}),
+        },
+        validateStatus: () => true,
+    });
+    if (sendRes.status === 204) {
+        return JSON.stringify({
+            success: true,
+            message: `${records.length} record(s) pushed to aDSO ${adsoName.toUpperCase()} (mode: ${mode}).`,
+            adso_name: adsoName.toUpperCase(),
+            record_count: records.length,
+            mode,
+        });
+    }
+    // Error — include response body for diagnosis
+    const errorBody = typeof sendRes.data === 'string'
+        ? sendRes.data
+        : JSON.stringify(sendRes.data);
+    throw new Error(`Push to ${adsoName.toUpperCase()} failed (HTTP ${sendRes.status}): ${errorBody}`);
+}
+/**
+ * bw_get_push_schema — fetch the JSON schema for an aDSO's write interface.
+ *
+ * Returns the field list, types, and required fields so the caller knows
+ * what to include in bw_push_data records.
+ */
+export async function bwGetPushSchema(adsoName) {
+    const base = pushBase(adsoName);
+    const auth = buildAuth();
+    const res = await axios.get(base, {
+        httpsAgent,
+        headers: {
+            'Authorization': auth,
+            'Accept': 'application/json',
+        },
+        validateStatus: () => true,
+    });
+    if (res.status !== 200) {
+        throw new Error(`Failed to fetch push schema for ${adsoName.toUpperCase()} (HTTP ${res.status}): ${JSON.stringify(res.data)}`);
+    }
+    return `Push schema for aDSO ${adsoName.toUpperCase()}:\n\n${JSON.stringify(res.data, null, 2)}`;
+}