@mcp-abap-adt/adt-clients 0.1.0

package/bin/unlock-test-objects.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * Utility script to unlock all test objects from .locks/active-locks.json
+ *
+ * Usage:
+ *   node bin/unlock-test-objects.js [options]
+ *   adt-unlock-objects [options]
+ *
+ * Options:
+ *   --locks-dir <path>    Lock registry directory (default: .locks)
+ *   --env <path>          Path to .env file (default: .env)
+ *   -h, --help            Show help message
+ */
+
+const path = require('path');
+const fs = require('fs');
+const dotenv = require('dotenv');
+
+// Show help if requested
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+🔓 Unlock Test Objects - Utility to unlock all objects from lock registry
+
+Usage:
+  node bin/unlock-test-objects.js [options]
+  adt-unlock-objects [options]
+
+Options:
+  --locks-dir <path>    Lock registry directory (default: .locks)
+  --env <path>          Path to .env file (default: .env)
+  -h, --help            Show this help message
+
+Description:
+  This utility reads all active locks from .locks/active-locks.json and attempts
+  to unlock them on the SAP server. After successful unlock, locks are removed
+  from the registry.
+
+  The script uses JWT auto-refresh if refresh credentials are available in .env.
+
+Environment Variables (from .env):
+  SAP_URL              - SAP system URL
+  SAP_CLIENT           - SAP client (optional)
+  SAP_AUTH_TYPE        - Authentication type: basic, jwt, xsuaa
+  SAP_JWT_TOKEN        - JWT token (for jwt/xsuaa auth)
+  SAP_REFRESH_TOKEN     - Refresh token (optional, for auto-refresh)
+  SAP_UAA_URL          - UAA URL (optional, for auto-refresh)
+  SAP_UAA_CLIENT_ID    - UAA client ID (optional, for auto-refresh)
+  SAP_UAA_CLIENT_SECRET - UAA client secret (optional, for auto-refresh)
+  SAP_USERNAME         - Username (for basic auth)
+  SAP_PASSWORD         - Password (for basic auth)
+`);
+  process.exit(0);
+}
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    locksDir: '.locks',
+    envPath: '.env'
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--locks-dir' && i + 1 < args.length) {
+      options.locksDir = args[++i];
+    } else if (arg === '--env' && i + 1 < args.length) {
+      options.envPath = args[++i];
+    }
+  }
+
+  return options;
+}
+
+// Load environment
+const options = parseArgs();
+const envPath = process.env.MCP_ENV_PATH || path.resolve(__dirname, '..', options.envPath);
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+const { createAbapConnection } = require('@mcp-abap-adt/connection');
+const { LockStateManager } = require('../dist/utils/lockStateManager');
+const { unlockClass } = require('../dist/core/class/unlock');
+const { unlockInterface } = require('../dist/core/interface/unlock');
+const { unlockProgram } = require('../dist/core/program/unlock');
+const { unlockFunctionModule } = require('../dist/core/functionModule/unlock');
+const { unlockDomain } = require('../dist/core/domain/unlock');
+const { unlockDataElement } = require('../dist/core/dataElement/unlock');
+const { unlockDDLS } = require('../dist/core/view/unlock');
+const { unlockStructure } = require('../dist/core/structure/unlock');
+const { unlockTable } = require('../dist/core/table/unlock');
+const { unlockPackage } = require('../dist/core/package/unlock');
+
+function getConfig() {
+  const rawUrl = process.env.SAP_URL;
+  const url = rawUrl ? rawUrl.split('#')[0].trim() : rawUrl;
+  const rawClient = process.env.SAP_CLIENT;
+  const client = rawClient ? rawClient.split('#')[0].trim() : rawClient;
+  const rawAuthType = process.env.SAP_AUTH_TYPE || 'basic';
+  const authType = rawAuthType.split('#')[0].trim();
+
+  if (!url || !/^https?:\/\//.test(url)) {
+    throw new Error(`Missing or invalid SAP_URL: ${url}`);
+  }
+
+  const config = {
+    url,
+    authType: authType === 'xsuaa' ? 'jwt' : authType,
+  };
+
+  if (client) {
+    config.client = client;
+  }
+
+  if (authType === 'jwt' || authType === 'xsuaa') {
+    const jwtToken = process.env.SAP_JWT_TOKEN;
+    if (!jwtToken) {
+      throw new Error('Missing SAP_JWT_TOKEN for JWT authentication');
+    }
+    config.jwtToken = jwtToken;
+
+    // Add refresh credentials if available (for auto-refresh)
+    if (process.env.SAP_REFRESH_TOKEN) {
+      config.refreshToken = process.env.SAP_REFRESH_TOKEN;
+    }
+    if (process.env.SAP_UAA_URL) {
+      config.uaaUrl = process.env.SAP_UAA_URL;
+    }
+    if (process.env.SAP_UAA_CLIENT_ID) {
+      config.uaaClientId = process.env.SAP_UAA_CLIENT_ID;
+    }
+    if (process.env.SAP_UAA_CLIENT_SECRET) {
+      config.uaaClientSecret = process.env.SAP_UAA_CLIENT_SECRET;
+    }
+  } else {
+    const username = process.env.SAP_USERNAME;
+    const password = process.env.SAP_PASSWORD;
+    if (!username || !password) {
+      throw new Error('Missing SAP_USERNAME or SAP_PASSWORD for basic authentication');
+    }
+    config.username = username;
+    config.password = password;
+  }
+
+  return config;
+}
+
+/**
+ * Unlock object based on type
+ */
+async function unlockObject(connection, lock) {
+  const { objectType, objectName, functionGroupName, lockHandle, sessionId } = lock;
+
+  switch (objectType) {
+    case 'class':
+      return await unlockClass(connection, objectName, lockHandle, sessionId);
+    case 'interface':
+      return await unlockInterface(connection, objectName, lockHandle, sessionId);
+    case 'program':
+      return await unlockProgram(connection, objectName, lockHandle, sessionId);
+    case 'fm':
+      if (!functionGroupName) {
+        throw new Error(`Function group name required for FM: ${objectName}`);
+      }
+      return await unlockFunctionModule(connection, functionGroupName, objectName, lockHandle, sessionId);
+    case 'domain':
+      return await unlockDomain(connection, objectName, lockHandle, sessionId);
+    case 'dataElement':
+      return await unlockDataElement(connection, objectName, lockHandle, sessionId);
+    case 'view':
+      return await unlockDDLS(connection, objectName, lockHandle, sessionId);
+    case 'structure':
+      return await unlockStructure(connection, objectName, lockHandle, sessionId);
+    case 'table':
+      return await unlockTable(connection, objectName, lockHandle, sessionId);
+    case 'package':
+      return await unlockPackage(connection, objectName, lockHandle, sessionId);
+    default:
+      throw new Error(`Unknown object type: ${objectType}`);
+  }
+}
+
+function formatLockInfo(lock) {
+  const objectId = lock.functionGroupName
+    ? `${lock.functionGroupName}/${lock.objectName}`
+    : lock.objectName;
+  return `${lock.objectType.toUpperCase()}: ${objectId}`;
+}
+
+async function unlockTestObjects() {
+  try {
+    const config = getConfig();
+    const connection = createAbapConnection(config, console);
+
+    // Load lock registry
+    const lockManager = new LockStateManager(options.locksDir);
+    const locks = lockManager.getAllLocks();
+
+    if (locks.length === 0) {
+      console.log('✅ No active locks found in registry');
+      return;
+    }
+
+    console.log(`🔓 Found ${locks.length} lock(s) in registry\n`);
+
+    let successCount = 0;
+    let failCount = 0;
+
+    // Connection will auto-connect on first request (with JWT refresh if needed)
+    for (const lock of locks) {
+      try {
+        const lockInfo = formatLockInfo(lock);
+        console.log(`Attempting to unlock ${lockInfo}...`);
+
+        await unlockObject(connection, lock);
+
+        // Remove from registry after successful unlock
+        lockManager.removeLock(lock.objectType, lock.objectName, lock.functionGroupName);
+
+        console.log(`✅ Unlocked: ${lockInfo}\n`);
+        successCount++;
+      } catch (error) {
+        const lockInfo = formatLockInfo(lock);
+        console.log(`❌ Failed to unlock ${lockInfo}: ${error.message}\n`);
+        failCount++;
+
+        // Don't remove from registry if unlock failed - might be locked by another session
+        // User can manually clean up later
+      }
+    }
+
+    console.log('\n📊 Summary:');
+    console.log(`   ✅ Successfully unlocked: ${successCount}`);
+    console.log(`   ❌ Failed to unlock: ${failCount}`);
+
+    if (failCount > 0) {
+      console.log('\n💡 Note: Failed unlocks may be locked by another session or already unlocked.');
+      console.log('   You can check with: adt-manage-locks list');
+    }
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+unlockTestObjects();

package/dist/clients/CrudClient.d.ts

@@ -0,0 +1,48 @@
+/**
+ * CrudClient - Full CRUD operations for SAP ADT
+ *
+ * Extends ReadOnlyClient with Create, Update, and Delete operations.
+ * All methods return raw AxiosResponse - no MCP formatting.
+ *
+ * All implementations are in core/{object}/ modules (e.g., core/program/, core/class/).
+ * Read operations are inherited from ReadOnlyClient (which delegates to core/{object}/read.ts).
+ */
+import { ReadOnlyClient } from './ReadOnlyClient';
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import * as programOps from '../core/program';
+import * as classOps from '../core/class';
+import * as domainOps from '../core/domain';
+import * as dataElementOps from '../core/dataElement';
+import * as interfaceOps from '../core/interface';
+import * as tableOps from '../core/table';
+import * as structureOps from '../core/structure';
+import * as viewOps from '../core/view';
+import * as functionGroupOps from '../core/functionGroup';
+import * as functionModuleOps from '../core/functionModule';
+import * as packageOps from '../core/package';
+import * as transportOps from '../core/transport';
+import * as deleteOps from '../core/delete';
+export declare class CrudClient extends ReadOnlyClient {
+    constructor(connection: AbapConnection);
+    createProgram(params: programOps.CreateProgramParams): Promise<AxiosResponse>;
+    updateProgramSource(params: programOps.UpdateProgramSourceParams): Promise<AxiosResponse>;
+    createClass(params: classOps.CreateClassParams): Promise<AxiosResponse>;
+    createDomain(params: domainOps.CreateDomainParams): Promise<AxiosResponse>;
+    updateDomain(params: domainOps.UpdateDomainParams): Promise<AxiosResponse>;
+    createDataElement(params: dataElementOps.CreateDataElementParams): Promise<AxiosResponse>;
+    updateDataElement(params: dataElementOps.UpdateDataElementParams): Promise<AxiosResponse>;
+    createInterface(params: interfaceOps.CreateInterfaceParams): Promise<AxiosResponse>;
+    updateInterfaceSource(params: interfaceOps.UpdateInterfaceSourceParams): Promise<AxiosResponse>;
+    createTable(params: tableOps.CreateTableParams): Promise<AxiosResponse>;
+    createStructure(params: structureOps.CreateStructureParams): Promise<AxiosResponse>;
+    createView(params: viewOps.CreateViewParams): Promise<AxiosResponse>;
+    updateViewSource(params: viewOps.UpdateViewSourceParams): Promise<AxiosResponse>;
+    createFunctionGroup(params: functionGroupOps.CreateFunctionGroupParams): Promise<AxiosResponse>;
+    createFunctionModule(params: functionModuleOps.CreateFunctionModuleParams): Promise<AxiosResponse>;
+    updateFunctionModuleSource(params: functionModuleOps.UpdateFunctionModuleSourceParams): Promise<AxiosResponse>;
+    createPackage(params: packageOps.CreatePackageParams): Promise<AxiosResponse>;
+    createTransport(params: transportOps.CreateTransportParams): Promise<AxiosResponse>;
+    deleteObject(params: deleteOps.DeleteObjectParams): Promise<AxiosResponse>;
+}
+//# sourceMappingURL=CrudClient.d.ts.map

package/dist/clients/CrudClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrudClient.d.ts","sourceRoot":"","sources":["../../src/clients/CrudClient.ts"],"names":[],"mappings":"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"}

package/dist/clients/CrudClient.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * CrudClient - Full CRUD operations for SAP ADT
+ *
+ * Extends ReadOnlyClient with Create, Update, and Delete operations.
+ * All methods return raw AxiosResponse - no MCP formatting.
+ *
+ * All implementations are in core/{object}/ modules (e.g., core/program/, core/class/).
+ * Read operations are inherited from ReadOnlyClient (which delegates to core/{object}/read.ts).
+ */
+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.CrudClient = void 0;
+const ReadOnlyClient_1 = require("./ReadOnlyClient");
+const programOps = __importStar(require("../core/program"));
+const classOps = __importStar(require("../core/class"));
+const domainOps = __importStar(require("../core/domain"));
+const dataElementOps = __importStar(require("../core/dataElement"));
+const interfaceOps = __importStar(require("../core/interface"));
+const tableOps = __importStar(require("../core/table"));
+const structureOps = __importStar(require("../core/structure"));
+const viewOps = __importStar(require("../core/view"));
+const functionGroupOps = __importStar(require("../core/functionGroup"));
+const functionModuleOps = __importStar(require("../core/functionModule"));
+const packageOps = __importStar(require("../core/package"));
+const transportOps = __importStar(require("../core/transport"));
+const deleteOps = __importStar(require("../core/delete"));
+class CrudClient extends ReadOnlyClient_1.ReadOnlyClient {
+    constructor(connection) {
+        super(connection);
+    }
+    // Program operations
+    async createProgram(params) {
+        return programOps.createProgram(this.connection, params);
+    }
+    async updateProgramSource(params) {
+        return programOps.updateProgramSource(this.connection, params);
+    }
+    // Class operations
+    async createClass(params) {
+        return classOps.createClass(this.connection, params);
+    }
+    // Domain operations
+    async createDomain(params) {
+        return domainOps.createDomain(this.connection, params);
+    }
+    async updateDomain(params) {
+        return domainOps.updateDomain(this.connection, params);
+    }
+    // DataElement operations
+    async createDataElement(params) {
+        return dataElementOps.createDataElement(this.connection, params);
+    }
+    async updateDataElement(params) {
+        return dataElementOps.updateDataElement(this.connection, params);
+    }
+    // Interface operations
+    async createInterface(params) {
+        return interfaceOps.createInterface(this.connection, params);
+    }
+    async updateInterfaceSource(params) {
+        return interfaceOps.updateInterfaceSource(this.connection, params);
+    }
+    // Table operations
+    async createTable(params) {
+        return tableOps.createTable(this.connection, params);
+    }
+    // Structure operations
+    async createStructure(params) {
+        return structureOps.createStructure(this.connection, params);
+    }
+    // View operations
+    async createView(params) {
+        return viewOps.createView(this.connection, params);
+    }
+    async updateViewSource(params) {
+        return viewOps.updateViewSource(this.connection, params);
+    }
+    // FunctionGroup operations
+    async createFunctionGroup(params) {
+        return functionGroupOps.createFunctionGroup(this.connection, params);
+    }
+    // FunctionModule operations
+    async createFunctionModule(params) {
+        return functionModuleOps.createFunctionModule(this.connection, params);
+    }
+    async updateFunctionModuleSource(params) {
+        return functionModuleOps.updateFunctionModuleSource(this.connection, params);
+    }
+    // Package operations
+    async createPackage(params) {
+        return packageOps.createPackage(this.connection, params);
+    }
+    // Transport operations
+    async createTransport(params) {
+        return transportOps.createTransport(this.connection, params);
+    }
+    // Delete operations (common for all object types)
+    async deleteObject(params) {
+        return deleteOps.deleteObject(this.connection, params);
+    }
+}
+exports.CrudClient = CrudClient;

package/dist/clients/LockClient.d.ts

@@ -0,0 +1,28 @@
+import { AbapConnection } from '@mcp-abap-adt/connection';
+export type LockableObjectType = 'class' | 'program' | 'interface' | 'function_group' | 'function_module' | 'table' | 'structure' | 'view' | 'domain' | 'data_element' | 'package';
+export interface LockRequest {
+    objectType: LockableObjectType;
+    objectName: string;
+    sessionId?: string;
+}
+export interface LockResult {
+    objectType: LockableObjectType;
+    objectName: string;
+    lockHandle: string;
+    sessionId: string;
+    transportRequest?: string;
+}
+export interface UnlockRequest {
+    objectType: LockableObjectType;
+    objectName: string;
+    lockHandle: string;
+    sessionId: string;
+}
+export declare class LockClient {
+    private connection;
+    constructor(connection: AbapConnection);
+    lock(request: LockRequest): Promise<LockResult>;
+    unlock(request: UnlockRequest): Promise<void>;
+    private splitFunctionModuleName;
+}
+//# sourceMappingURL=LockClient.d.ts.map

package/dist/clients/LockClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockClient.d.ts","sourceRoot":"","sources":["../../src/clients/LockClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAyB1D,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,SAAS,GACT,WAAW,GACX,gBAAgB,GAChB,iBAAiB,GACjB,OAAO,GACP,WAAW,GACX,MAAM,GACN,QAAQ,GACR,cAAc,GACd,SAAS,CAAC;AAEd,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,UAAU;IACT,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,cAAc;IAExC,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAwD/C,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IA6CnD,OAAO,CAAC,uBAAuB;CAWhC"}

package/dist/clients/LockClient.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockClient = void 0;
+const sessionUtils_1 = require("../utils/sessionUtils");
+const lock_1 = require("../core/class/lock");
+const unlock_1 = require("../core/class/unlock");
+const lock_2 = require("../core/program/lock");
+const unlock_2 = require("../core/program/unlock");
+const lock_3 = require("../core/interface/lock");
+const unlock_3 = require("../core/interface/unlock");
+const lock_4 = require("../core/functionGroup/lock");
+const unlock_4 = require("../core/functionGroup/unlock");
+const lock_5 = require("../core/functionModule/lock");
+const unlock_5 = require("../core/functionModule/unlock");
+const lock_6 = require("../core/structure/lock");
+const unlock_6 = require("../core/structure/unlock");
+const lock_7 = require("../core/table/lock");
+const unlock_7 = require("../core/table/unlock");
+const lock_8 = require("../core/domain/lock");
+const unlock_8 = require("../core/domain/unlock");
+const lock_9 = require("../core/dataElement/lock");
+const unlock_9 = require("../core/dataElement/unlock");
+const lock_10 = require("../core/view/lock");
+const unlock_10 = require("../core/view/unlock");
+const lock_11 = require("../core/package/lock");
+const unlock_11 = require("../core/package/unlock");
+class LockClient {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    async lock(request) {
+        const sessionId = request.sessionId || (0, sessionUtils_1.generateSessionId)();
+        const objectType = request.objectType.toLowerCase();
+        const objectName = request.objectName.toUpperCase();
+        switch (objectType) {
+            case 'class': {
+                const lockHandle = await (0, lock_1.lockClass)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'program': {
+                const lockHandle = await (0, lock_2.lockProgram)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'interface': {
+                const { lockHandle, corrNr } = await (0, lock_3.lockInterface)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId, transportRequest: corrNr };
+            }
+            case 'function_group': {
+                const lockHandle = await (0, lock_4.lockFunctionGroup)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'function_module': {
+                const { group, module } = this.splitFunctionModuleName(objectName);
+                const lockHandle = await (0, lock_5.lockFunctionModule)(this.connection, group, module, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'table': {
+                const lockHandle = await (0, lock_7.acquireTableLockHandle)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'structure': {
+                const lockHandle = await (0, lock_6.lockStructure)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'view': {
+                const lockHandle = await (0, lock_10.lockDDLS)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'domain': {
+                const lockHandle = await (0, lock_8.lockDomain)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'data_element': {
+                const lockHandle = await (0, lock_9.lockDataElement)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            case 'package': {
+                const lockHandle = await (0, lock_11.lockPackage)(this.connection, objectName, sessionId);
+                return { objectType, objectName, lockHandle, sessionId };
+            }
+            default:
+                throw new Error(`Unsupported object type for lock: ${objectType}`);
+        }
+    }
+    async unlock(request) {
+        const objectType = request.objectType.toLowerCase();
+        const objectName = request.objectName.toUpperCase();
+        switch (objectType) {
+            case 'class':
+                await (0, unlock_1.unlockClass)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'program':
+                await (0, unlock_2.unlockProgram)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'interface':
+                await (0, unlock_3.unlockInterface)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'function_group':
+                await (0, unlock_4.unlockFunctionGroup)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'function_module': {
+                const { group, module } = this.splitFunctionModuleName(objectName);
+                await (0, unlock_5.unlockFunctionModule)(this.connection, group, module, request.lockHandle, request.sessionId);
+                return;
+            }
+            case 'table':
+                await (0, unlock_7.unlockTable)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'structure':
+                await (0, unlock_6.unlockStructure)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'view':
+                await (0, unlock_10.unlockDDLS)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'domain':
+                await (0, unlock_8.unlockDomain)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'data_element':
+                await (0, unlock_9.unlockDataElement)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            case 'package':
+                await (0, unlock_11.unlockPackage)(this.connection, objectName, request.lockHandle, request.sessionId);
+                return;
+            default:
+                throw new Error(`Unsupported object type for unlock: ${objectType}`);
+        }
+    }
+    splitFunctionModuleName(value) {
+        const separator = value.includes('|') ? '|' : '/';
+        const [group, module] = value.split(separator);
+        if (!group || !module) {
+            throw new Error('Function module name must include function group (e.g., ZFGROUP|Z_FM_NAME)');
+        }
+        return {
+            group,
+            module
+        };
+    }
+}
+exports.LockClient = LockClient;

package/dist/clients/ManagementClient.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ManagementClient - Management operations for SAP ADT
+ *
+ * Provides methods for object activation and syntax checking.
+ * All methods return raw AxiosResponse - no MCP formatting.
+ *
+ * All implementations are in core/managementOperations.ts to avoid code duplication.
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export declare class ManagementClient {
+    private connection;
+    constructor(connection: AbapConnection);
+    /**
+     * Activate ABAP objects
+     */
+    activateObject(objects: Array<{
+        name: string;
+        type: string;
+    }>): Promise<AxiosResponse>;
+    /**
+     * Activate multiple objects with explicit URIs or inferred types
+     */
+    activateObjectsGroup(objects: Array<{
+        name: string;
+        type?: string;
+        uri?: string;
+    }>, preaudit?: boolean): Promise<AxiosResponse>;
+    /**
+     * Check ABAP object syntax
+     */
+    checkObject(name: string, type: string, version?: string): Promise<AxiosResponse>;
+}
+//# sourceMappingURL=ManagementClient.d.ts.map

package/dist/clients/ManagementClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManagementClient.d.ts","sourceRoot":"","sources":["../../src/clients/ManagementClient.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC,qBAAa,gBAAgB;IACf,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,cAAc;IAE9C;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAS1F;;OAEG;IACG,oBAAoB,CACxB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAC7D,QAAQ,GAAE,OAAc,GACvB,OAAO,CAAC,aAAa,CAAC;IAQzB;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;CAMxF"}