@st-gr/abap-adt-skill 1.0.0

package/dist/client.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatelessClient = getStatelessClient;
+exports.getClient = getClient;
+exports.withStatefulSession = withStatefulSession;
+const abap_adt_api_patched_1 = require("@st-gr/abap-adt-api-patched");
+const network_1 = require("./util/network");
+const systems_1 = require("./commands/systems");
+const credentials_1 = require("./util/credentials");
+let client;
+let statelessClient;
+async function getStatelessClient() {
+    if (statelessClient)
+        return statelessClient;
+    const c = await getClient();
+    statelessClient = c.statelessClone;
+    return statelessClient;
+}
+async function getClient() {
+    var _a;
+    if (client)
+        return client;
+    // Load connection: env vars take precedence, then fall back to ~/.sap/adt-connection.json
+    const conn = (0, systems_1.loadConnection)();
+    const url = process.env.ADT_URL || (conn === null || conn === void 0 ? void 0 : conn.url) || "";
+    const defaultUser = (process.env.USERNAME || process.env.USER || "").toUpperCase();
+    const user = process.env.ADT_USER || (conn === null || conn === void 0 ? void 0 : conn.user) || defaultUser;
+    let pass = process.env.ADT_PASS || "";
+    const sapClient = process.env.ADT_CLIENT || (conn === null || conn === void 0 ? void 0 : conn.client) || "";
+    const language = process.env.ADT_LANGUAGE || (conn === null || conn === void 0 ? void 0 : conn.language) || "EN";
+    const allowSelfSigned = process.env.ADT_ALLOW_SELF_SIGNED !== undefined
+        ? process.env.ADT_ALLOW_SELF_SIGNED !== "false"
+        : (_a = conn === null || conn === void 0 ? void 0 : conn.allowSelfSigned) !== null && _a !== void 0 ? _a : true;
+    // Decrypt stored password if no ADT_PASS env var
+    if (!pass && (conn === null || conn === void 0 ? void 0 : conn.encryptedPassword) && (0, credentials_1.isWindows)()) {
+        try {
+            pass = (0, credentials_1.decryptDPAPI)(conn.encryptedPassword);
+        }
+        catch (err) {
+            console.error(`Warning: Failed to decrypt stored password: ${err.message}`);
+        }
+    }
+    if (!url || !user) {
+        console.error(`Error: No connection configured.`);
+        console.error(`Run 'abap-adt systems connect <SID> [client]' first, or set ADT_URL + ADT_USER env vars.`);
+        process.exit(1);
+    }
+    if (!pass) {
+        const shell = (process.env.SHELL || process.env.ComSpec || "").toLowerCase();
+        const isPosh = shell.includes("powershell") || shell.includes("pwsh") || !!process.env.PSModulePath;
+        const isCmd = !isPosh && shell.includes("cmd");
+        const example = isPosh ? '$env:ADT_PASS = "<your_password>"'
+            : isCmd ? 'set ADT_PASS=<your_password>'
+                : 'export ADT_PASS="<your_password>"';
+        console.error(`Error: No password. Set ADT_PASS or run 'abap-adt systems connect' to store credentials.`);
+        console.error(`  ${example}`);
+        process.exit(1);
+    }
+    const options = allowSelfSigned ? (0, abap_adt_api_patched_1.createSSLConfig)(true) : {};
+    // VPN safety: verify private IP before sending credentials over HTTP
+    if (url.startsWith("http://")) {
+        const hostname = new URL(url).hostname;
+        await (0, network_1.assertPrivateHost)(hostname);
+    }
+    client = new abap_adt_api_patched_1.ADTClient(url, user, pass, sapClient, language, options);
+    await client.login();
+    return client;
+}
+async function withStatefulSession(fn) {
+    const c = await getClient();
+    c.stateful = abap_adt_api_patched_1.session_types.stateful;
+    try {
+        return await fn(c);
+    }
+    finally {
+        c.stateful = abap_adt_api_patched_1.session_types.stateless;
+        c.dropSession();
+    }
+}

package/dist/commands/activate.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateCommand = activateCommand;
+exports.inactiveObjectsCommand = inactiveObjectsCommand;
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+async function activateCommand(objectName, objectUrl, options) {
+    const client = await (0, client_1.getClient)();
+    const result = await client.activate(objectName, objectUrl);
+    if (options.json) {
+        (0, formatter_1.output)(result, true);
+        return;
+    }
+    if (result.success) {
+        console.log(`Activation successful: ${objectName}`);
+    }
+    else {
+        console.log(`Activation failed: ${objectName}`);
+    }
+    if (result.messages && result.messages.length > 0) {
+        console.log("\nMessages:");
+        for (const msg of result.messages) {
+            const severity = msg.type || "I";
+            const line = msg.line ? `:${msg.line}` : "";
+            console.log(`  [${severity}]${line} ${msg.shortText}`);
+            if (msg.href)
+                console.log(`        ${msg.href}`);
+        }
+    }
+    if (result.inactive && result.inactive.length > 0) {
+        console.log("\nRemaining inactive objects:");
+        for (const obj of result.inactive) {
+            if (obj.object) {
+                console.log(`  ${obj.object["adtcore:name"]} (${obj.object["adtcore:type"]})`);
+            }
+        }
+    }
+    if (!result.success)
+        process.exit(1);
+}
+async function inactiveObjectsCommand(options) {
+    const client = await (0, client_1.getClient)();
+    const objects = await client.inactiveObjects();
+    if (options.json) {
+        (0, formatter_1.output)(objects, true);
+        return;
+    }
+    if (objects.length === 0) {
+        console.log("No inactive objects.");
+        return;
+    }
+    console.log("Inactive objects:");
+    for (const record of objects) {
+        if (record.object) {
+            console.log(`  ${record.object["adtcore:name"]} (${record.object["adtcore:type"]}) - ${record.object["adtcore:uri"]}`);
+        }
+    }
+}

package/dist/commands/atc.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atcRunCommand = atcRunCommand;
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+async function atcRunCommand(objectUrl, options) {
+    const client = await (0, client_1.getClient)();
+    const variant = options.variant || "DEFAULT";
+    const maxResults = options.max ? parseInt(options.max, 10) : undefined;
+    // Create ATC run
+    const runResult = await client.createAtcRun(variant, objectUrl, maxResults);
+    // Get worklist
+    const worklist = await client.atcWorklists(runResult.id);
+    if (options.json) {
+        (0, formatter_1.output)(worklist, true);
+        return;
+    }
+    if (!worklist.objects || worklist.objects.length === 0) {
+        console.log("ATC check: No findings.");
+        return;
+    }
+    console.log(`ATC Run ID: ${runResult.id}`);
+    console.log(`Timestamp: ${worklist.timestamp || ""}`);
+    console.log();
+    for (const obj of worklist.objects) {
+        console.log(`Object: ${obj.name} (${obj.type})`);
+        if (obj.findings) {
+            for (const finding of obj.findings) {
+                const prio = finding.priority || "";
+                const check = finding.checkId || "";
+                const msg = finding.messageTitle || "";
+                const loc = finding.location ? ` at ${finding.location.uri}` : "";
+                console.log(`  [P${prio}] ${check}: ${msg}${loc}`);
+                if (finding.uri)
+                    console.log(`    URI: ${finding.uri}`);
+            }
+        }
+    }
+}

package/dist/commands/classinfo.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classinfoCommand = classinfoCommand;
+const client_1 = require("../client");
+async function classinfoCommand(objectUrl, options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const root = await client.classComponents(objectUrl);
+    if (options.json) {
+        console.log(JSON.stringify(root, null, 2));
+        return;
+    }
+    printComponent(root, 0);
+}
+function printComponent(comp, depth) {
+    const indent = "  ".repeat(depth);
+    const name = comp["adtcore:name"] || "";
+    const type = comp["adtcore:type"] || "";
+    const desc = comp["adtcore:description"] || "";
+    const visibility = comp["abapsource:visibility"] || "";
+    const parts = [name];
+    if (type)
+        parts.push(`(${type})`);
+    if (visibility)
+        parts.push(`[${visibility}]`);
+    if (desc)
+        parts.push(`— ${desc}`);
+    console.log(`${indent}${parts.join(" ")}`);
+    if (comp.components) {
+        for (const child of comp.components) {
+            printComponent(child, depth + 1);
+        }
+    }
+}

package/dist/commands/completion.js

@@ -0,0 +1,57 @@
+"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.completionCommand = completionCommand;
+const fs = __importStar(require("fs"));
+const client_1 = require("../client");
+async function completionCommand(sourceUrl, options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const source = fs.readFileSync(options.sourceFile, "utf-8");
+    const line = parseInt(options.line);
+    const column = parseInt(options.column);
+    const proposals = await client.codeCompletion(sourceUrl, source, line, column);
+    if (options.json) {
+        console.log(JSON.stringify(proposals, null, 2));
+        return;
+    }
+    if (proposals.length === 0) {
+        console.log("No completions available.");
+        return;
+    }
+    console.log(`${proposals.length} completion(s):\n`);
+    for (const p of proposals) {
+        console.log(`  ${p.IDENTIFIER}`);
+    }
+}

package/dist/commands/create.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommand = createCommand;
+const client_1 = require("../client");
+const TYPE_ALIASES = {
+    "program": "PROG/P",
+    "prog": "PROG/P",
+    "class": "CLAS/OC",
+    "clas": "CLAS/OC",
+    "interface": "INTF/OI",
+    "intf": "INTF/OI",
+    "function-group": "FUGR/F",
+    "fugr": "FUGR/F",
+    "function-module": "FUGR/FF",
+    "include": "PROG/I",
+    "table": "TABL/DT",
+    "tabl": "TABL/DT",
+    "structure": "TABL/DS",
+    "cds": "DDLS/DF",
+    "ddls": "DDLS/DF",
+    "data-element": "DTEL/DE",
+    "dtel": "DTEL/DE",
+    "domain": "DOMA/DD",
+    "doma": "DOMA/DD",
+    "package": "DEVC/K",
+    "devc": "DEVC/K",
+    "message-class": "MSAG/N",
+    "msag": "MSAG/N",
+    "dcls": "DCLS/DL",
+    "ddlx": "DDLX/EX",
+    "service-definition": "SRVD/SRV",
+    "service-binding": "SRVB/SVB"
+};
+function resolveType(input) {
+    const lower = input.toLowerCase();
+    if (TYPE_ALIASES[lower])
+        return TYPE_ALIASES[lower];
+    // Try as raw type ID (e.g. "CLAS/OC")
+    if (input.includes("/"))
+        return input;
+    console.error(`Unknown type: ${input}`);
+    console.error(`Available types: ${Object.keys(TYPE_ALIASES).join(", ")}`);
+    process.exit(1);
+}
+async function createCommand(type, name, options) {
+    const client = await (0, client_1.getClient)();
+    const objtype = resolveType(type);
+    let parentName;
+    let parentPath;
+    if (objtype === "FUGR/FF" || objtype === "FUGR/I") {
+        // Function modules/includes: parent is the function group, not the package
+        const fugr = options.functionGroup || options.package;
+        if (!fugr) {
+            console.error("Error: --function-group (or --package with function group name) is required for function modules");
+            process.exit(1);
+        }
+        parentName = fugr.toUpperCase();
+        parentPath = options.parentPath || `/sap/bc/adt/functions/groups/${encodeURIComponent(parentName.toLowerCase())}`;
+    }
+    else {
+        parentName = options.package.toUpperCase();
+        parentPath = options.parentPath || `/sap/bc/adt/packages/${encodeURIComponent(parentName.toLowerCase())}`;
+    }
+    await client.createObject(objtype, name.toUpperCase(), parentName, options.description, parentPath, options.responsible || "", options.transport || "");
+    console.log(`Created ${objtype} ${name.toUpperCase()} in ${parentName}`);
+    if (options.transport) {
+        console.log(`Transport: ${options.transport}`);
+    }
+}

package/dist/commands/debug.js

@@ -0,0 +1,217 @@
+"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.debugListenCommand = debugListenCommand;
+exports.debugAttachCommand = debugAttachCommand;
+exports.debugBreakpointsCommand = debugBreakpointsCommand;
+exports.debugStepCommand = debugStepCommand;
+exports.debugStackCommand = debugStackCommand;
+exports.debugVariablesCommand = debugVariablesCommand;
+exports.debugChildVariablesCommand = debugChildVariablesCommand;
+const crypto = __importStar(require("crypto"));
+const abap_adt_api_patched_1 = require("@st-gr/abap-adt-api-patched");
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+function generateId() {
+    return crypto.randomUUID().toUpperCase();
+}
+// Store debug session IDs in environment for continuity across CLI invocations
+function getTerminalId() {
+    return process.env.ADT_TERMINAL_ID || generateId();
+}
+function getIdeId() {
+    return process.env.ADT_IDE_ID || generateId();
+}
+async function debugListenCommand(options) {
+    const mode = (options.mode || "user");
+    const terminalId = getTerminalId();
+    const ideId = getIdeId();
+    console.error(`Terminal ID: ${terminalId}`);
+    console.error(`IDE ID: ${ideId}`);
+    console.error(`Mode: ${mode}`);
+    console.error("Waiting for debuggee... (set a breakpoint in SAP and run the program)");
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const user = options.user || client.username;
+        const result = await client.debuggerListen(mode, terminalId, ideId, user);
+        if (!result) {
+            console.log("No debuggee found (timeout or no breakpoint hit).");
+            return;
+        }
+        if ((0, abap_adt_api_patched_1.isDebugListenerError)(result)) {
+            console.error(`Debug listener error: ${result.message.text}`);
+            if (result.conflictText) {
+                console.error(`Conflict: ${result.conflictText}`);
+            }
+            process.exit(1);
+        }
+        if ((0, abap_adt_api_patched_1.isDebuggee)(result)) {
+            if (options.json) {
+                (0, formatter_1.output)(result, true);
+                return;
+            }
+            console.log(`\nDebuggee found!`);
+            console.log(`  Debuggee ID: ${result.DEBUGGEE_ID}`);
+            console.log(`  User: ${result.DEBUGGEE_USER}`);
+            console.log(`  Program: ${result.PRG_CURR}`);
+            console.log(`  Include: ${result.INCL_CURR}`);
+            console.log(`  Line: ${result.LINE_CURR}`);
+            console.log(`  Terminal ID: ${terminalId}`);
+            console.log(`  IDE ID: ${ideId}`);
+            console.log(`\nTo attach: debug attach ${result.DEBUGGEE_ID} --terminal-id ${terminalId} --ide-id ${ideId}`);
+        }
+    });
+}
+async function debugAttachCommand(debuggeeId, options) {
+    const mode = (options.mode || "user");
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const user = options.user || client.username;
+        const result = await client.debuggerAttach(mode, debuggeeId, user);
+        if (options.json) {
+            (0, formatter_1.output)(result, true);
+            return;
+        }
+        console.log(`Attached to debuggee: ${debuggeeId}`);
+        console.log(`  Session: ${result.debugSessionId}`);
+        console.log(`  Stepping possible: ${result.isSteppingPossible}`);
+        if (result.reachedBreakpoints && result.reachedBreakpoints.length > 0) {
+            console.log(`  Reached breakpoints:`);
+            for (const bp of result.reachedBreakpoints) {
+                console.log(`    ${bp.id} (${bp.kind})`);
+            }
+        }
+        console.log(`\nAvailable actions:`);
+        for (const action of result.actions) {
+            if (!action.disabled) {
+                console.log(`  ${action.name}: ${action.title}`);
+            }
+        }
+    });
+}
+async function debugBreakpointsCommand(uri, options) {
+    const mode = (options.mode || "user");
+    const terminalId = options.terminalId || getTerminalId();
+    const ideId = options.ideId || getIdeId();
+    const clientId = options.clientId || generateId();
+    const client = await (0, client_1.getClient)();
+    const user = options.user || client.username;
+    const result = await client.debuggerSetBreakpoints(mode, terminalId, ideId, clientId, [uri], user);
+    if (options.json) {
+        (0, formatter_1.output)(result, true);
+        return;
+    }
+    for (const bp of result) {
+        if ("uri" in bp) {
+            console.log(`Breakpoint set: ${bp.id} at ${bp.uri.uri} (${bp.kind})`);
+        }
+        else if ("errorMessage" in bp) {
+            console.error(`Breakpoint error: ${bp.errorMessage}`);
+        }
+    }
+}
+async function debugStepCommand(stepType, options) {
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const result = options.uri
+            ? await client.debuggerStep(stepType, options.uri)
+            : await client.debuggerStep(stepType);
+        if (options.json) {
+            (0, formatter_1.output)(result, true);
+            return;
+        }
+        console.log(`Step: ${stepType}`);
+        console.log(`  Session: ${result.debugSessionId}`);
+        console.log(`  Stepping possible: ${result.isSteppingPossible}`);
+        if (result.reachedBreakpoints && result.reachedBreakpoints.length > 0) {
+            console.log(`  Reached breakpoints:`);
+            for (const bp of result.reachedBreakpoints) {
+                console.log(`    ${bp.id} (${bp.kind})`);
+            }
+        }
+    });
+}
+async function debugStackCommand(options) {
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const result = await client.debuggerStackTrace();
+        if (options.json) {
+            (0, formatter_1.output)(result, true);
+            return;
+        }
+        console.log(`Stack (RFC: ${result.isRfc}, Same system: ${result.isSameSystem}):`);
+        for (const entry of result.stack) {
+            if ("programName" in entry) {
+                const prog = entry.programName;
+                const line = entry.line;
+                const event = "eventName" in entry ? entry.eventName : "";
+                const pos = entry.stackPosition;
+                console.log(`  [${pos}] ${prog} line ${line} (${event})`);
+            }
+        }
+    });
+}
+async function debugVariablesCommand(variables, options) {
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const result = await client.debuggerVariables(variables);
+        if (options.json) {
+            (0, formatter_1.output)(result, true);
+            return;
+        }
+        for (const v of result) {
+            const type = v.DECLARED_TYPE_NAME || v.TECHNICAL_TYPE;
+            const meta = v.META_TYPE;
+            console.log(`${v.NAME} = ${v.VALUE} (${type}, ${meta}, len=${v.LENGTH})`);
+        }
+    });
+}
+async function debugChildVariablesCommand(parents, options) {
+    await (0, client_1.withStatefulSession)(async (client) => {
+        const result = await client.debuggerChildVariables(parents);
+        if (options.json) {
+            (0, formatter_1.output)(result, true);
+            return;
+        }
+        if (result.hierarchies.length > 0) {
+            console.log("Hierarchies:");
+            for (const h of result.hierarchies) {
+                console.log(`  ${h.PARENT_ID} -> ${h.CHILD_NAME} (${h.CHILD_ID})`);
+            }
+        }
+        if (result.variables.length > 0) {
+            console.log("\nVariables:");
+            for (const v of result.variables) {
+                const type = v.DECLARED_TYPE_NAME || v.TECHNICAL_TYPE;
+                console.log(`  ${v.NAME} = ${v.VALUE} (${type}, ${v.META_TYPE})`);
+            }
+        }
+    });
+}

package/dist/commands/definition.js

@@ -0,0 +1,66 @@
+"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.definitionCommand = definitionCommand;
+const fs = __importStar(require("fs"));
+const client_1 = require("../client");
+async function definitionCommand(objectUrl, options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const line = parseInt(options.line);
+    const startCol = parseInt(options.startCol);
+    const endCol = parseInt(options.endCol);
+    // Source body is needed for the API — read from file or fetch from server
+    let source;
+    if (options.sourceFile) {
+        source = fs.readFileSync(options.sourceFile, "utf-8");
+    }
+    else {
+        source = await client.getObjectSource(objectUrl);
+    }
+    const result = await client.findDefinition(objectUrl, source, line, startCol, endCol, options.implementation || false, options.mainProgram || "");
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.url) {
+        console.log("No definition found.");
+        return;
+    }
+    console.log(`URI: ${result.url}`);
+    if (result.line)
+        console.log(`Line: ${result.line}`);
+    if (result.column)
+        console.log(`Column: ${result.column}`);
+}

package/dist/commands/delete.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCommand = deleteCommand;
+const client_1 = require("../client");
+async function deleteCommand(objectUrl, options) {
+    await (0, client_1.withStatefulSession)(async (c) => {
+        const lock = await c.lock(objectUrl);
+        const lockHandle = lock.LOCK_HANDLE;
+        try {
+            let transport = options.transport || lock.CORRNR;
+            if (!transport) {
+                const info = await c.transportInfo(objectUrl);
+                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.");
+                        await c.unLock(objectUrl, lockHandle);
+                        process.exit(1);
+                    }
+                }
+            }
+            await c.deleteObject(objectUrl, lockHandle, transport || undefined);
+            console.log(`Deleted: ${objectUrl}`);
+        }
+        catch (err) {
+            try {
+                await c.unLock(objectUrl, lockHandle);
+            }
+            catch ( /* ignore */_a) { /* ignore */ }
+            throw err;
+        }
+    });
+}