@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/common/handleLockObject.d.ts

@@ -0,0 +1,57 @@
+/**
+ * LockObject Handler - Lock ABAP object for modification via ADT API
+ *
+ * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations.
+ * Returns lock handle that must be used in subsequent requests with the same session_id.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "LockObject";
+    readonly description: "Lock an ABAP object for modification. Returns lock handle that must be used in subsequent update/unlock operations with the same session_id. Use GetSession first to get a session_id, then use that session_id for lock, update, and unlock operations.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'";
+                readonly enum: readonly ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"];
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["object_name", "object_type"];
+    };
+};
+/**
+ * Main handler for LockObject MCP tool
+ *
+ * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations
+ */
+export declare function handleLockObject(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleLockObject.d.ts.map

package/dist/handlers/common/handleLockObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleLockObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleLockObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlB,CAAC;AAaX;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,GAAG;;;;;;GAgK/C"}

package/dist/handlers/common/handleLockObject.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * LockObject Handler - Lock ABAP object for modification via ADT API
+ *
+ * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations.
+ * Returns lock handle that must be used in subsequent requests with the same session_id.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleLockObject = handleLockObject;
+const utils_1 = require("../../lib/utils");
+const sessionUtils_1 = require("../../lib/sessionUtils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "LockObject",
+    description: "Lock an ABAP object for modification. Returns lock handle that must be used in subsequent update/unlock operations with the same session_id. Use GetSession first to get a session_id, then use that session_id for lock, update, and unlock operations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_name: {
+                type: "string",
+                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME"
+            },
+            object_type: {
+                type: "string",
+                description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'",
+                enum: ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"]
+            },
+            session_id: {
+                type: "string",
+                description: "Session ID from GetSession. If not provided, a new session will be created."
+            },
+            session_state: {
+                type: "object",
+                description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.",
+                properties: {
+                    cookies: { type: "string" },
+                    csrf_token: { type: "string" },
+                    cookie_store: { type: "object" }
+                }
+            }
+        },
+        required: ["object_name", "object_type"]
+    }
+};
+/**
+ * Main handler for LockObject MCP tool
+ *
+ * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations
+ */
+async function handleLockObject(args) {
+    try {
+        const { object_name, object_type, session_id, session_state } = args;
+        // Validation
+        if (!object_name || !object_type) {
+            return (0, utils_1.return_error)(new Error('object_name and object_type are required'));
+        }
+        const validTypes = ['class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package'];
+        if (!validTypes.includes(object_type.toLowerCase())) {
+            return (0, utils_1.return_error)(new Error(`Invalid object_type. Must be one of: ${validTypes.join(', ')}`));
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        // Restore session state if provided
+        if (session_id && session_state) {
+            connection.setSessionState({
+                cookies: session_state.cookies || null,
+                csrfToken: session_state.csrf_token || null,
+                cookieStore: session_state.cookie_store || {}
+            });
+        }
+        else {
+            // Ensure connection is established
+            await connection.connect();
+        }
+        // Use provided session_id or generate new one
+        const desiredSessionId = session_id || (0, sessionUtils_1.generateSessionId)();
+        const objectName = object_name.toUpperCase();
+        const objectType = object_type.toLowerCase();
+        utils_1.logger.info(`Starting object lock: ${objectName} (type: ${objectType}, session: ${desiredSessionId.substring(0, 8)}...)`);
+        try {
+            let lockHandle;
+            // Call appropriate lock method based on object type
+            switch (objectType) {
+                case 'class':
+                    await client.lockClass(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'program':
+                    await client.lockProgram(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'interface':
+                    await client.lockInterface(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'function_group':
+                    await client.lockFunctionGroup(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'function_module':
+                    // Function module requires function group name which is not provided in this generic handler
+                    return (0, utils_1.return_error)(new Error('Function module locking via LockObject is not supported. Function modules require function group name.'));
+                case 'table':
+                    await client.lockTable(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'structure':
+                    await client.lockStructure(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'view':
+                    await client.lockView(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'domain':
+                    await client.lockDomain(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'data_element':
+                    await client.lockDataElement(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'behavior_definition':
+                    await client.lockBehaviorDefinition(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'metadata_extension':
+                    await client.lockMetadataExtension(objectName);
+                    lockHandle = client.getLockHandle();
+                    break;
+                case 'package':
+                    // Package requires superPackage parameter - need to fetch it or handle differently
+                    return (0, utils_1.return_error)(new Error('Package locking via LockObject is not supported. Use specific package operations.'));
+                default:
+                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
+            }
+            if (!lockHandle) {
+                throw new Error(`Lock did not return a lock handle for object ${objectName}`);
+            }
+            // Get updated session state after lock
+            const updatedSessionState = connection.getSessionState();
+            utils_1.logger.info(`✅ LockObject completed: ${objectName}`);
+            utils_1.logger.info(`   Lock handle: ${lockHandle.substring(0, 20)}...`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    object_name: objectName,
+                    object_type: objectType,
+                    session_id: desiredSessionId,
+                    lock_handle: lockHandle,
+                    transport_request: null, // CrudClient doesn't expose transport request
+                    session_state: updatedSessionState ? {
+                        cookies: updatedSessionState.cookies,
+                        csrf_token: updatedSessionState.csrfToken,
+                        cookie_store: updatedSessionState.cookieStore
+                    } : null,
+                    message: `Object ${objectName} locked successfully. Use this lock_handle and session_id for subsequent update/unlock operations.`
+                }, null, 2)
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error locking object ${objectName}:`, error);
+            // Parse error message
+            let errorMessage = `Failed to lock object: ${error.message || String(error)}`;
+            if (error.response?.status === 404) {
+                errorMessage = `Object ${objectName} not found.`;
+            }
+            else if (error.response?.status === 409) {
+                errorMessage = `Object ${objectName} is already locked by another user.`;
+            }
+            else if (error.response?.data && typeof error.response.data === 'string') {
+                try {
+                    const { XMLParser } = require('fast-xml-parser');
+                    const parser = new XMLParser({
+                        ignoreAttributes: false,
+                        attributeNamePrefix: '@_'
+                    });
+                    const errorData = parser.parse(error.response.data);
+                    const errorMsg = errorData['exc:exception']?.message?.['#text'] || errorData['exc:exception']?.message;
+                    if (errorMsg) {
+                        errorMessage = `SAP Error: ${errorMsg}`;
+                    }
+                }
+                catch (parseError) {
+                    // Ignore parse errors
+                }
+            }
+            return (0, utils_1.return_error)(new Error(errorMessage));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/common/handleUnlockObject.d.ts

@@ -0,0 +1,61 @@
+/**
+ * UnlockObject Handler - Unlock ABAP object after modification via ADT API
+ *
+ * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations.
+ * Must use the same session_id and lock_handle from the LockObject operation.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UnlockObject";
+    readonly description: "Unlock an ABAP object after modification. Must use the same session_id and lock_handle from the LockObject operation.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'";
+                readonly enum: readonly ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"];
+            };
+            readonly lock_handle: {
+                readonly type: "string";
+                readonly description: "Lock handle from LockObject operation";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Session ID from LockObject operation. Must be the same as used in LockObject.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Session state from LockObject (cookies, csrf_token, cookie_store). Required if session_id is provided.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["object_name", "object_type", "lock_handle", "session_id"];
+    };
+};
+/**
+ * Main handler for UnlockObject MCP tool
+ *
+ * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations
+ */
+export declare function handleUnlockObject(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUnlockObject.d.ts.map

package/dist/handlers/common/handleUnlockObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUnlockObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleUnlockObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmClB,CAAC;AAcX;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GA2IjD"}

package/dist/handlers/common/handleUnlockObject.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * UnlockObject Handler - Unlock ABAP object after modification via ADT API
+ *
+ * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations.
+ * Must use the same session_id and lock_handle from the LockObject operation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleUnlockObject = handleUnlockObject;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "UnlockObject",
+    description: "Unlock an ABAP object after modification. Must use the same session_id and lock_handle from the LockObject operation.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_name: {
+                type: "string",
+                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME"
+            },
+            object_type: {
+                type: "string",
+                description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'",
+                enum: ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"]
+            },
+            lock_handle: {
+                type: "string",
+                description: "Lock handle from LockObject operation"
+            },
+            session_id: {
+                type: "string",
+                description: "Session ID from LockObject operation. Must be the same as used in LockObject."
+            },
+            session_state: {
+                type: "object",
+                description: "Session state from LockObject (cookies, csrf_token, cookie_store). Required if session_id is provided.",
+                properties: {
+                    cookies: { type: "string" },
+                    csrf_token: { type: "string" },
+                    cookie_store: { type: "object" }
+                }
+            }
+        },
+        required: ["object_name", "object_type", "lock_handle", "session_id"]
+    }
+};
+/**
+ * Main handler for UnlockObject MCP tool
+ *
+ * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations
+ */
+async function handleUnlockObject(args) {
+    try {
+        const { object_name, object_type, lock_handle, session_id, session_state } = args;
+        // Validation
+        if (!object_name || !object_type || !lock_handle || !session_id) {
+            return (0, utils_1.return_error)(new Error('object_name, object_type, lock_handle, and session_id are required'));
+        }
+        const validTypes = ['class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'];
+        if (!validTypes.includes(object_type.toLowerCase())) {
+            return (0, utils_1.return_error)(new Error(`Invalid object_type. Must be one of: ${validTypes.join(', ')}`));
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        // Restore session state if provided
+        if (session_state) {
+            connection.setSessionState({
+                cookies: session_state.cookies || null,
+                csrfToken: session_state.csrf_token || null,
+                cookieStore: session_state.cookie_store || {}
+            });
+        }
+        else {
+            // Ensure connection is established
+            await connection.connect();
+        }
+        const objectName = object_name.toUpperCase();
+        const objectType = object_type.toLowerCase();
+        utils_1.logger.info(`Starting object unlock: ${objectName} (type: ${objectType}, session: ${session_id.substring(0, 8)}...)`);
+        try {
+            // Call appropriate unlock method based on object type
+            switch (objectType) {
+                case 'class':
+                    await client.unlockClass(objectName, lock_handle);
+                    break;
+                case 'program':
+                    await client.unlockProgram(objectName, lock_handle);
+                    break;
+                case 'interface':
+                    await client.unlockInterface(objectName, lock_handle);
+                    break;
+                case 'function_group':
+                    await client.unlockFunctionGroup(objectName, lock_handle);
+                    break;
+                case 'function_module':
+                    // Function module requires function group name which is not provided in this generic handler
+                    return (0, utils_1.return_error)(new Error('Function module unlocking via UnlockObject is not supported. Function modules require function group name.'));
+                case 'table':
+                    await client.unlockTable(objectName, lock_handle);
+                    break;
+                case 'structure':
+                    await client.unlockStructure(objectName, lock_handle);
+                    break;
+                case 'view':
+                    await client.unlockView(objectName, lock_handle);
+                    break;
+                case 'domain':
+                    await client.unlockDomain(objectName, lock_handle);
+                    break;
+                case 'data_element':
+                    await client.unlockDataElement(objectName, lock_handle);
+                    break;
+                case 'behavior_definition':
+                    await client.unlockBehaviorDefinition(objectName, lock_handle);
+                    break;
+                case 'metadata_extension':
+                    await client.unlockMetadataExtension(objectName, lock_handle);
+                    break;
+                case 'package':
+                    // Package requires superPackage parameter - need to fetch it or handle differently
+                    return (0, utils_1.return_error)(new Error('Package unlocking via UnlockObject is not supported. Use specific package operations.'));
+                default:
+                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
+            }
+            // Get updated session state after unlock
+            const updatedSessionState = connection.getSessionState();
+            utils_1.logger.info(`✅ UnlockObject completed: ${objectName}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    object_name: objectName,
+                    object_type: objectType,
+                    session_id: session_id,
+                    session_state: updatedSessionState ? {
+                        cookies: updatedSessionState.cookies,
+                        csrf_token: updatedSessionState.csrfToken,
+                        cookie_store: updatedSessionState.cookieStore
+                    } : null,
+                    message: `Object ${objectName} unlocked successfully.`
+                }, null, 2)
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error unlocking object ${objectName}:`, error);
+            // Parse error message
+            let errorMessage = `Failed to unlock object: ${error.message || String(error)}`;
+            if (error.response?.status === 404) {
+                errorMessage = `Object ${objectName} not found.`;
+            }
+            else if (error.response?.status === 400) {
+                errorMessage = `Invalid lock handle or session. Make sure you're using the same session_id and lock_handle from LockObject.`;
+            }
+            else if (error.response?.data && typeof error.response.data === 'string') {
+                try {
+                    const { XMLParser } = require('fast-xml-parser');
+                    const parser = new XMLParser({
+                        ignoreAttributes: false,
+                        attributeNamePrefix: '@_'
+                    });
+                    const errorData = parser.parse(error.response.data);
+                    const errorMsg = errorData['exc:exception']?.message?.['#text'] || errorData['exc:exception']?.message;
+                    if (errorMsg) {
+                        errorMessage = `SAP Error: ${errorMsg}`;
+                    }
+                }
+                catch (parseError) {
+                    // Ignore parse errors
+                }
+            }
+            return (0, utils_1.return_error)(new Error(errorMessage));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/common/handleValidateObject.d.ts

@@ -0,0 +1,58 @@
+/**
+ * ValidateObject Handler - Validate ABAP object name via ADT API
+ *
+ * Uses validateObjectName from @mcp-abap-adt/adt-clients/core for all operations.
+ * Connection management handled internally.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "ValidateObject";
+    readonly description: "Validate an ABAP object name before creation. Checks if the name is valid and available. Returns validation result with success status and message. Can use session_id and session_state from GetSession to maintain the same session.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Object name to validate (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE)";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'table', 'structure', 'view', 'domain', 'data_element', 'package'";
+                readonly enum: readonly ["class", "program", "interface", "function_group", "table", "structure", "view", "domain", "data_element", "package"];
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["object_name", "object_type"];
+    };
+};
+/**
+ * Main handler for ValidateObject MCP tool
+ *
+ * Uses validateObjectName from @mcp-abap-adt/adt-clients/core for all operations
+ * Connection management handled internally
+ */
+export declare function handleValidateObject(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleValidateObject.d.ts.map

package/dist/handlers/common/handleValidateObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleValidateObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleValidateObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlB,CAAC;AAaX;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG;;;;;;GA8InD"}