@st-gr/abap-adt-skill 1.0.0

package/dist/commands/transport.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportInfoCommand = transportInfoCommand;
+exports.transportCreateCommand = transportCreateCommand;
+exports.transportReleaseCommand = transportReleaseCommand;
+exports.transportListCommand = transportListCommand;
+exports.transportDeleteCommand = transportDeleteCommand;
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+async function transportInfoCommand(objectUrl, options) {
+    const client = await (0, client_1.getClient)();
+    const info = await client.transportInfo(objectUrl, options.devclass);
+    if (options.json) {
+        (0, formatter_1.output)(info, true);
+        return;
+    }
+    console.log(`Object: ${info.OBJECTNAME} (${info.OBJECT})`);
+    console.log(`Package: ${info.DEVCLASS}`);
+    console.log(`Operation: ${info.OPERATION}`);
+    console.log(`Result: ${info.RESULT}`);
+    console.log(`Recording: ${info.RECORDING}`);
+    if (info.LOCKS) {
+        console.log(`\nLocked by transport: ${info.LOCKS.HEADER.TRKORR}`);
+        console.log(`  Owner: ${info.LOCKS.HEADER.AS4USER}`);
+        console.log(`  Description: ${info.LOCKS.HEADER.AS4TEXT}`);
+    }
+    if (info.TRANSPORTS && info.TRANSPORTS.length > 0) {
+        console.log("\nAvailable transports:");
+        for (const t of info.TRANSPORTS) {
+            console.log(`  ${t.TRKORR} - ${t.AS4TEXT} (${t.AS4USER}, ${t.TRSTATUS})`);
+        }
+    }
+}
+async function transportCreateCommand(objectUrl, options) {
+    const client = await (0, client_1.getClient)();
+    const transport = await client.createTransport(objectUrl, options.description, options.devclass);
+    if (options.json) {
+        (0, formatter_1.output)({ transport }, true);
+        return;
+    }
+    console.log(`Transport created: ${transport}`);
+}
+async function transportReleaseCommand(transportNumber, options) {
+    const client = await (0, client_1.getClient)();
+    const reports = await client.transportRelease(transportNumber, options.ignoreLocks || false, options.ignoreAtc || false);
+    if (options.json) {
+        (0, formatter_1.output)(reports, true);
+        return;
+    }
+    for (const report of reports) {
+        console.log(`Reporter: ${report["chkrun:reporter"]}`);
+        console.log(`Status: ${report["chkrun:status"]}`);
+        console.log(`Status Text: ${report["chkrun:statusText"]}`);
+        if (report.messages && report.messages.length > 0) {
+            for (const msg of report.messages) {
+                console.log(`  [${msg["chkrun:type"]}] ${msg["chkrun:shortText"]}`);
+            }
+        }
+    }
+}
+async function transportListCommand(options) {
+    const client = await (0, client_1.getClient)();
+    const user = options.user || client.username;
+    const transports = await client.userTransports(user);
+    if (options.json) {
+        (0, formatter_1.output)(transports, true);
+        return;
+    }
+    const printRequests = (requests, indent) => {
+        for (const req of requests) {
+            console.log(`${indent}${req["tm:number"]} - ${req["tm:desc"]} (${req["tm:owner"]}, ${req["tm:status"]})`);
+            if (req.tasks) {
+                for (const task of req.tasks) {
+                    console.log(`${indent}  Task: ${task["tm:number"]} - ${task["tm:desc"]} (${task["tm:owner"]})`);
+                }
+            }
+        }
+    };
+    for (const target of transports.workbench) {
+        console.log(`\nWorkbench Target: ${target["tm:name"]} (${target["tm:desc"]})`);
+        if (target.modifiable.length > 0) {
+            console.log("  Modifiable:");
+            printRequests(target.modifiable, "    ");
+        }
+        if (target.released.length > 0) {
+            console.log("  Released:");
+            printRequests(target.released, "    ");
+        }
+    }
+    for (const target of transports.customizing) {
+        console.log(`\nCustomizing Target: ${target["tm:name"]} (${target["tm:desc"]})`);
+        if (target.modifiable.length > 0) {
+            console.log("  Modifiable:");
+            printRequests(target.modifiable, "    ");
+        }
+        if (target.released.length > 0) {
+            console.log("  Released:");
+            printRequests(target.released, "    ");
+        }
+    }
+}
+async function transportDeleteCommand(transportNumber, options) {
+    const client = await (0, client_1.getClient)();
+    await client.transportDelete(transportNumber);
+    if (options.json) {
+        (0, formatter_1.output)({ deleted: transportNumber }, true);
+        return;
+    }
+    console.log(`Transport deleted: ${transportNumber}`);
+}

package/dist/commands/users.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usersCommand = usersCommand;
+const client_1 = require("../client");
+async function usersCommand(options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const users = await client.systemUsers();
+    if (options.json) {
+        console.log(JSON.stringify(users, null, 2));
+        return;
+    }
+    if (users.length === 0) {
+        console.log("No users found.");
+        return;
+    }
+    for (const u of users) {
+        console.log(`${u.id}  ${u.title || ""}`);
+    }
+}

package/dist/commands/whereused.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereusedCommand = whereusedCommand;
+const client_1 = require("../client");
+async function whereusedCommand(objectUrl, options) {
+    var _a;
+    const client = await (0, client_1.getStatelessClient)();
+    const line = options.line ? parseInt(options.line) : undefined;
+    const column = options.column ? parseInt(options.column) : undefined;
+    const refs = await client.usageReferences(objectUrl, line, column);
+    if (options.json) {
+        console.log(JSON.stringify(refs, null, 2));
+        return;
+    }
+    if (refs.length === 0) {
+        console.log("No references found.");
+        return;
+    }
+    console.log(`Found ${refs.length} reference(s):\n`);
+    for (const ref of refs) {
+        const name = ref["adtcore:name"] || "";
+        const type = ref["adtcore:type"] || "";
+        const uri = ref.uri || "";
+        const pkg = ((_a = ref.packageRef) === null || _a === void 0 ? void 0 : _a["adtcore:name"]) || "";
+        console.log(`  ${padRight(name, 30)} ${padRight(type, 12)} ${padRight(pkg, 16)} ${uri}`);
+    }
+}
+function padRight(s, len) {
+    return s.length >= len ? s : s + " ".repeat(len - s.length);
+}

package/dist/commands/write.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCommand = writeCommand;
+const fs = __importStar(require("fs"));
+const abap_adt_api_patched_1 = require("@st-gr/abap-adt-api-patched");
+const client_1 = require("../client");
+async function writeCommand(objectUrl, options) {
+    if (!fs.existsSync(options.sourceFile)) {
+        console.error(`Source file not found: ${options.sourceFile}`);
+        process.exit(1);
+    }
+    const source = fs.readFileSync(options.sourceFile, "utf-8");
+    // Resolve source URL and object URL BEFORE entering stateful session
+    const client = await (0, client_1.getClient)();
+    let sourceUrl = objectUrl;
+    let lockUrl = objectUrl;
+    let needsTestIncludeCreation = false;
+    let className = "";
+    // Handle class includes (e.g. /sap/bc/adt/oo/classes/zcl_foo/includes/testclasses)
+    const includeMatch = objectUrl.match(/^(\/sap\/bc\/adt\/oo\/classes\/([^/]+))\/includes\/(\w+)$/);
+    if (includeMatch) {
+        lockUrl = includeMatch[1]; // lock the class, not the include
+        className = includeMatch[2];
+        const includeName = includeMatch[3];
+        // Check if this include already exists
+        const struct = await client.statelessClone.objectStructure(lockUrl);
+        if ((0, abap_adt_api_patched_1.isClassStructure)(struct)) {
+            const includes = abap_adt_api_patched_1.ADTClient.classIncludes(struct);
+            const existing = includes.get(includeName);
+            if (existing) {
+                sourceUrl = existing;
+            }
+            else if (includeName === "testclasses") {
+                needsTestIncludeCreation = true;
+                sourceUrl = objectUrl;
+            }
+            else {
+                console.error(`Include '${includeName}' not found. Available: ${Array.from(includes.keys()).join(", ")}`);
+                process.exit(1);
+            }
+        }
+    }
+    else if (!objectUrl.includes("/source/")) {
+        const struct = await client.statelessClone.objectStructure(objectUrl);
+        sourceUrl = abap_adt_api_patched_1.ADTClient.mainInclude(struct);
+    }
+    await (0, client_1.withStatefulSession)(async (c) => {
+        // Lock the OBJECT URL (not the source URL) — SAP ADT requires locking the object, not its source
+        const lock = await c.lock(lockUrl);
+        const lockHandle = lock.LOCK_HANDLE;
+        try {
+            // Determine transport
+            let transport = options.transport || lock.CORRNR;
+            if (!transport) {
+                const info = await c.transportInfo(sourceUrl !== objectUrl ? sourceUrl : lockUrl);
+                if (info.RECORDING && info.RECORDING !== " ") {
+                    if (info.TRANSPORTS && info.TRANSPORTS.length > 0) {
+                        transport = info.TRANSPORTS[0].TRKORR;
+                        console.log(`Using transport: ${transport} (${info.TRANSPORTS[0].AS4TEXT})`);
+                    }
+                    else {
+                        console.error("Transport required but none available. Create one with: transport create");
+                        console.error(`Package: ${info.DEVCLASS}`);
+                        await c.unLock(lockUrl, lockHandle);
+                        process.exit(1);
+                    }
+                }
+            }
+            // Create testclasses include if it doesn't exist yet
+            if (needsTestIncludeCreation) {
+                await c.createTestInclude(className, lockHandle, transport || "");
+                // Re-read structure to get the actual source URI
+                const struct = await c.objectStructure(lockUrl);
+                if ((0, abap_adt_api_patched_1.isClassStructure)(struct)) {
+                    const includes = abap_adt_api_patched_1.ADTClient.classIncludes(struct);
+                    const testUrl = includes.get("testclasses");
+                    if (testUrl) {
+                        sourceUrl = testUrl;
+                    }
+                }
+            }
+            // Write source to the SOURCE URL (with lock handle obtained from object lock)
+            await c.setObjectSource(sourceUrl, source, lockHandle, transport || undefined);
+            console.log(`Source written successfully to ${sourceUrl}`);
+            if (transport) {
+                console.log(`Transport: ${transport}`);
+            }
+        }
+        finally {
+            try {
+                await c.unLock(lockUrl, lockHandle);
+            }
+            catch (_a) {
+                // Ignore unlock errors
+            }
+        }
+    });
+}

package/dist/diag-debug.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Combined debug test: set breakpoint + listen in a single stateful session.
+ */
+const abap_adt_api_1 = require("abap-adt-api");
+const ADT_URL = process.env.ADT_URL;
+const ADT_USER = process.env.ADT_USER;
+const ADT_PASS = process.env.ADT_PASS;
+const ADT_CLIENT = process.env.ADT_CLIENT || "";
+async function main() {
+    const client = new abap_adt_api_1.ADTClient(ADT_URL, ADT_USER, ADT_PASS, ADT_CLIENT, "EN", (0, abap_adt_api_1.createSSLConfig)(true));
+    await client.login();
+    client.stateful = abap_adt_api_1.session_types.stateful;
+    const terminalId = "DEBUG-TEST-001";
+    const ideId = "DEBUG-IDE-TEST-001";
+    const clientId = "BP-CLIENT-001";
+    const user = ADT_USER;
+    // Step 1: Set external breakpoint on line 5 of ZSGR_TEST_42
+    console.log("\n=== Setting external breakpoint on line 5 ===");
+    const bpUri = "/sap/bc/adt/programs/programs/zsgr_test_42/source/main#start=5";
+    const bpResult = await client.debuggerSetBreakpoints("user", terminalId, ideId, clientId, [bpUri], user);
+    console.log("Breakpoint result:", JSON.stringify(bpResult, null, 2));
+    // Step 3: Listen (blocks until breakpoint hit or timeout)
+    console.log("\n=== Listening for debuggee (90s timeout) ===");
+    console.log(">>> Run ZSGR_TEST_42 in SE38 now! <<<");
+    // Use a timeout wrapper
+    const timeoutMs = 90000;
+    const listenPromise = client.debuggerListen("user", terminalId, ideId, user);
+    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs));
+    const result = await Promise.race([listenPromise, timeoutPromise]);
+    if (!result) {
+        console.log("\nTimeout — no debuggee caught.");
+    }
+    else {
+        console.log("\n=== DEBUGGEE CAUGHT! ===");
+        console.log(JSON.stringify(result, null, 2));
+    }
+    // Cleanup
+    try {
+        await client.debuggerDeleteListener("user", terminalId, ideId, user);
+    }
+    catch (_a) { }
+    client.stateful = abap_adt_api_1.session_types.stateless;
+    client.dropSession();
+}
+main().catch(e => { console.error("Fatal:", e.message); process.exit(1); });

package/dist/diag-raw.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Raw HTTP diagnostic: manually construct the lock → write → unlock sequence
+ * and dump every detail. Uses Node.js http module directly (no axios).
+ */
+const http = __importStar(require("http"));
+const abap_adt_api_1 = require("abap-adt-api");
+const ADT_URL = process.env.ADT_URL;
+const ADT_USER = process.env.ADT_USER;
+const ADT_PASS = process.env.ADT_PASS;
+const ADT_CLIENT = process.env.ADT_CLIENT || "";
+async function main() {
+    // Step 1: Use the library to log in + lock (these work fine via POST)
+    const client = new abap_adt_api_1.ADTClient(ADT_URL, ADT_USER, ADT_PASS, ADT_CLIENT, "EN", (0, abap_adt_api_1.createSSLConfig)(true));
+    await client.login();
+    client.stateful = abap_adt_api_1.session_types.stateful;
+    const objectUrl = "/sap/bc/adt/programs/programs/zsgr_test_42";
+    const sourceUrl = objectUrl + "/source/main";
+    console.log("=== LOCKING (via library) ===");
+    const lock = await client.lock(objectUrl);
+    console.log("Lock handle:", lock.LOCK_HANDLE);
+    console.log("Transport:", lock.CORRNR);
+    // Step 2: Extract session state from the library's HTTP handler
+    const h = client.h; // Access private AdtHTTP instance
+    const cookies = h.ascookies();
+    const csrfToken = h.csrfToken;
+    const baseURL = h.baseURL;
+    console.log("\n=== SESSION STATE ===");
+    console.log("Base URL:", baseURL);
+    console.log("Cookies:", cookies);
+    console.log("CSRF token:", csrfToken);
+    // Step 3: Make PUT request with raw Node.js http
+    const source = `REPORT zsgr_test_42.\n\nDATA lv_value TYPE i.\n\nBREAK-POINT.\nlv_value = 42.\nBREAK-POINT.\n\nWRITE: / 'The value is:', lv_value.\n`;
+    const sourceBytes = Buffer.from(source, "utf-8");
+    const parsed = new URL(baseURL);
+    const putPath = `${sourceUrl}?lockHandle=${encodeURIComponent(lock.LOCK_HANDLE)}${ADT_CLIENT ? `&sap-client=${ADT_CLIENT}` : ""}`;
+    const putHeaders = {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Content-Length": String(sourceBytes.length),
+        "Cookie": cookies,
+        "x-csrf-token": csrfToken,
+        "X-sap-adt-sessiontype": "stateful",
+        "Authorization": "Basic " + Buffer.from(`${ADT_USER}:${ADT_PASS}`).toString("base64"),
+        "Accept": "*/*",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+    };
+    if (lock.CORRNR) {
+        // Add transport to path
+    }
+    console.log("\n=== RAW PUT REQUEST ===");
+    console.log(`PUT ${putPath}`);
+    for (const [k, v] of Object.entries(putHeaders)) {
+        if (k === "Authorization")
+            console.log(`${k}: Basic ***`);
+        else
+            console.log(`${k}: ${v}`);
+    }
+    console.log(`\nBody (${sourceBytes.length} bytes):\n${source}`);
+    const putResult = await new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname: parsed.hostname,
+            port: parseInt(parsed.port || "8000"),
+            path: putPath,
+            method: "PUT",
+            headers: putHeaders,
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => { body += chunk.toString(); });
+            res.on("end", () => resolve({ status: res.statusCode, headers: res.headers, body }));
+        });
+        req.on("error", reject);
+        req.write(sourceBytes);
+        req.end();
+    });
+    console.log("\n=== RAW PUT RESPONSE ===");
+    console.log("Status:", putResult.status);
+    console.log("Headers:", JSON.stringify(putResult.headers, null, 2));
+    console.log("Body:", putResult.body);
+    // Step 4: Also try the SAME request as POST (for comparison)
+    console.log("\n\n=== RAW POST REQUEST (same params, different method) ===");
+    const postResult = await new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname: parsed.hostname,
+            port: parseInt(parsed.port || "8000"),
+            path: putPath,
+            method: "POST",
+            headers: putHeaders,
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => { body += chunk.toString(); });
+            res.on("end", () => resolve({ status: res.statusCode, headers: res.headers, body }));
+        });
+        req.on("error", reject);
+        req.write(sourceBytes);
+        req.end();
+    });
+    console.log("Status:", postResult.status);
+    console.log("Headers:", JSON.stringify(postResult.headers, null, 2));
+    console.log("Body:", postResult.body);
+    // Cleanup
+    try {
+        await client.unLock(objectUrl, lock.LOCK_HANDLE);
+        console.log("\n=== UNLOCKED ===");
+    }
+    catch (e) {
+        console.log("\nUnlock failed:", e.message);
+    }
+}
+main().catch(e => { console.error("Fatal:", e.message); process.exit(1); });

package/dist/diag-write.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abap_adt_api_1 = require("abap-adt-api");
+async function main() {
+    const baseUrl = process.env.ADT_URL;
+    const user = process.env.ADT_USER;
+    const pass = process.env.ADT_PASS;
+    const sapClient = process.env.ADT_CLIENT || "";
+    const language = process.env.ADT_LANGUAGE || "EN";
+    // Match extension behavior: for HTTP, pass empty options (no httpsAgent)
+    const isHttps = baseUrl.match(/^https:/i);
+    const options = isHttps ? { httpsAgent: new (require("https").Agent)({ keepAlive: true, rejectUnauthorized: false }) } : {};
+    console.log("URL protocol:", isHttps ? "HTTPS" : "HTTP");
+    console.log("Options:", JSON.stringify(Object.keys(options)));
+    const c = new abap_adt_api_1.ADTClient(baseUrl, user, pass, sapClient, language, options);
+    const objectUrl = "/sap/bc/adt/programs/programs/zsgr_test_42";
+    const sourceUrl = "/sap/bc/adt/programs/programs/zsgr_test_42/source/main";
+    const source = "REPORT zsgr_test_42.\n\nDATA lv_value TYPE i.\n\nBREAK-POINT.\nlv_value = 42.\nBREAK-POINT.\n\nWRITE: / 'Value of lv_value:', lv_value.\n";
+    console.log("=== Login ===");
+    await c.login();
+    console.log("Logged in");
+    c.stateful = abap_adt_api_1.session_types.stateful;
+    console.log("=== Lock ===");
+    const lock = await c.lock(objectUrl);
+    console.log("Lock handle:", lock.LOCK_HANDLE);
+    console.log("=== Write ===");
+    try {
+        await c.setObjectSource(sourceUrl, source, lock.LOCK_HANDLE);
+        console.log("SUCCESS!");
+    }
+    catch (e) {
+        console.log("FAILED:", e.message);
+    }
+    console.log("=== Unlock ===");
+    try {
+        await c.unLock(objectUrl, lock.LOCK_HANDLE);
+    }
+    catch (_a) { }
+    c.stateful = abap_adt_api_1.session_types.stateless;
+    await c.dropSession();
+}
+main().catch(e => { console.error(e); process.exit(1); });