@mcp-abap-adt/core 4.8.1 → 4.8.3

package/dist/src/handlers/compact/high/handleHandlerDumpList.d.ts

@@ -0,0 +1,49 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerDumpList";
+    readonly available_in: readonly ["onprem"];
+    readonly description: "Runtime dump list. object_type: not used. Required: none. Optional: user, inlinecount, top, skip, orderby. Response: JSON.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly user: {
+                readonly type: "string";
+                readonly description: "Filter dumps by user.";
+            };
+            readonly inlinecount: {
+                readonly type: "string";
+                readonly enum: readonly ["allpages", "none"];
+                readonly description: "Include total count in response.";
+            };
+            readonly top: {
+                readonly type: "number";
+                readonly description: "Limit number of returned dumps.";
+            };
+            readonly skip: {
+                readonly type: "number";
+                readonly description: "Offset for pagination.";
+            };
+            readonly orderby: {
+                readonly type: "string";
+                readonly description: "Sort expression.";
+            };
+        };
+        readonly required: readonly [];
+    };
+};
+type HandlerDumpListArgs = {
+    user?: string;
+    inlinecount?: 'allpages' | 'none';
+    top?: number;
+    skip?: number;
+    orderby?: string;
+};
+export declare function handleHandlerDumpList(context: HandlerContext, args: HandlerDumpListArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerDumpList.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerDumpList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpList.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerDumpList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GAG1B"}

package/dist/src/handlers/compact/high/handleHandlerDumpList.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerDumpList = handleHandlerDumpList;
+const handleRuntimeListDumps_1 = require("../../system/readonly/handleRuntimeListDumps");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerDumpList',
+    available_in: ['onprem'],
+    description: 'Runtime dump list. object_type: not used. Required: none. Optional: user, inlinecount, top, skip, orderby. Response: JSON.',
+    inputSchema: compactSchemas_1.compactDumpListSchema,
+};
+async function handleHandlerDumpList(context, args) {
+    return (0, handleRuntimeListDumps_1.handleRuntimeListDumps)(context, args);
+}
+//# sourceMappingURL=handleHandlerDumpList.js.map

package/dist/src/handlers/compact/high/handleHandlerDumpList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpList.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerDumpList.ts"],"names":[],"mappings":";;;AAoBA,sDAKC;AAxBD,yFAAsF;AACtF,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,YAAY,EAAE,CAAC,QAAQ,CAAU;IACjC,WAAW,EACT,4HAA4H;IAC9H,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAUJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,OAAO,IAAA,+CAAsB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerDumpView.d.ts

@@ -0,0 +1,35 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerDumpView";
+    readonly available_in: readonly ["onprem"];
+    readonly description: "Runtime dump view. object_type: not used. Required: dump_id*. Optional: view(default|summary|formatted). Response: JSON.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dump_id: {
+                readonly type: "string";
+                readonly description: "Runtime dump id.";
+            };
+            readonly view: {
+                readonly type: "string";
+                readonly enum: readonly ["default", "summary", "formatted"];
+                readonly default: "default";
+                readonly description: "Dump rendering mode.";
+            };
+        };
+        readonly required: readonly ["dump_id"];
+    };
+};
+type HandlerDumpViewArgs = {
+    dump_id: string;
+    view?: 'default' | 'summary' | 'formatted';
+};
+export declare function handleHandlerDumpView(context: HandlerContext, args: HandlerDumpViewArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerDumpView.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerDumpView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpView.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerDumpView.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;CAC5C,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GAG1B"}

package/dist/src/handlers/compact/high/handleHandlerDumpView.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerDumpView = handleHandlerDumpView;
+const handleRuntimeGetDumpById_1 = require("../../system/readonly/handleRuntimeGetDumpById");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerDumpView',
+    available_in: ['onprem'],
+    description: 'Runtime dump view. object_type: not used. Required: dump_id*. Optional: view(default|summary|formatted). Response: JSON.',
+    inputSchema: compactSchemas_1.compactDumpViewSchema,
+};
+async function handleHandlerDumpView(context, args) {
+    return (0, handleRuntimeGetDumpById_1.handleRuntimeGetDumpById)(context, args);
+}
+//# sourceMappingURL=handleHandlerDumpView.js.map

package/dist/src/handlers/compact/high/handleHandlerDumpView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpView.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerDumpView.ts"],"names":[],"mappings":";;;AAiBA,sDAKC;AArBD,6FAA0F;AAC1F,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,YAAY,EAAE,CAAC,QAAQ,CAAU;IACjC,WAAW,EACT,0HAA0H;IAC5H,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAOJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,OAAO,IAAA,mDAAwB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerGet.d.ts

@@ -0,0 +1,103 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerGet";
+    readonly available_in: readonly ["onprem", "cloud"];
+    readonly description: "Read operation. object_type required: PACKAGE(package_name*), DOMAIN(domain_name*), DATA_ELEMENT(data_element_name*), TABLE(table_name*), STRUCTURE(structure_name*), VIEW(view_name*), SERVICE_DEFINITION(service_definition_name*), SERVICE_BINDING(service_binding_name*), CLASS(class_name*), LOCAL_TEST_CLASS(class_name*), LOCAL_TYPES(class_name*), LOCAL_DEFINITIONS(class_name*), LOCAL_MACROS(class_name*), PROGRAM(program_name*), INTERFACE(interface_name*), FUNCTION_GROUP(function_group_name*), FUNCTION_MODULE(function_module_name*, function_group_name*), BEHAVIOR_DEFINITION(behavior_definition_name*), BEHAVIOR_IMPLEMENTATION(behavior_implementation_name*), METADATA_EXTENSION(metadata_extension_name*), UNIT_TEST(run_id*), CDS_UNIT_TEST(run_id*).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+                readonly description: "Class name.";
+            };
+            readonly interface_name: {
+                readonly type: "string";
+                readonly description: "Interface name.";
+            };
+            readonly program_name: {
+                readonly type: "string";
+                readonly description: "Program name.";
+            };
+            readonly domain_name: {
+                readonly type: "string";
+                readonly description: "Domain name.";
+            };
+            readonly data_element_name: {
+                readonly type: "string";
+                readonly description: "Data element name.";
+            };
+            readonly table_name: {
+                readonly type: "string";
+                readonly description: "Table name.";
+            };
+            readonly structure_name: {
+                readonly type: "string";
+                readonly description: "Structure name.";
+            };
+            readonly view_name: {
+                readonly type: "string";
+                readonly description: "View name.";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+                readonly description: "Function module name.";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "Function group name.";
+            };
+            readonly behavior_definition_name: {
+                readonly type: "string";
+                readonly description: "Behavior definition name.";
+            };
+            readonly behavior_implementation_name: {
+                readonly type: "string";
+                readonly description: "Behavior implementation name.";
+            };
+            readonly metadata_extension_name: {
+                readonly type: "string";
+                readonly description: "Metadata extension name.";
+            };
+            readonly service_definition_name: {
+                readonly type: "string";
+                readonly description: "Service definition name.";
+            };
+            readonly service_binding_name: {
+                readonly type: "string";
+                readonly description: "Service binding name.";
+            };
+            readonly run_id: {
+                readonly type: "string";
+                readonly description: "Unit test run id.";
+            };
+            readonly response_format: {
+                readonly type: "string";
+                readonly enum: readonly ["xml", "json", "plain"];
+                readonly description: "Response format for SERVICE_BINDING reads.";
+            };
+            readonly version: {
+                readonly type: "string";
+                readonly enum: readonly ["active", "inactive"];
+                readonly default: "active";
+                readonly description: "Object version to read/check.";
+            };
+        };
+        readonly required: readonly ["object_type"];
+    };
+};
+type HandlerGetArgs = {
+    object_type: CompactObjectType;
+} & Record<string, unknown>;
+export declare function handleHandlerGet(context: HandlerContext, args: HandlerGetArgs): Promise<unknown>;
+export {};
+//# sourceMappingURL=handleHandlerGet.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerGet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerGet.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerGet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,cAAc,GAAG;IAAE,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,MAAM,CAC/D,MAAM,EACN,OAAO,CACR,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,cAAc,oBAGrB"}

package/dist/src/handlers/compact/high/handleHandlerGet.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerGet = handleHandlerGet;
+const compactRouter_1 = require("./compactRouter");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerGet',
+    available_in: ['onprem', 'cloud'],
+    description: 'Read operation. object_type required: PACKAGE(package_name*), DOMAIN(domain_name*), DATA_ELEMENT(data_element_name*), TABLE(table_name*), STRUCTURE(structure_name*), VIEW(view_name*), SERVICE_DEFINITION(service_definition_name*), SERVICE_BINDING(service_binding_name*), CLASS(class_name*), LOCAL_TEST_CLASS(class_name*), LOCAL_TYPES(class_name*), LOCAL_DEFINITIONS(class_name*), LOCAL_MACROS(class_name*), PROGRAM(program_name*), INTERFACE(interface_name*), FUNCTION_GROUP(function_group_name*), FUNCTION_MODULE(function_module_name*, function_group_name*), BEHAVIOR_DEFINITION(behavior_definition_name*), BEHAVIOR_IMPLEMENTATION(behavior_implementation_name*), METADATA_EXTENSION(metadata_extension_name*), UNIT_TEST(run_id*), CDS_UNIT_TEST(run_id*).',
+    inputSchema: compactSchemas_1.compactGetSchema,
+};
+async function handleHandlerGet(context, args) {
+    return (0, compactRouter_1.routeCompactOperation)(context, 'get', args);
+}
+//# sourceMappingURL=handleHandlerGet.js.map

package/dist/src/handlers/compact/high/handleHandlerGet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerGet.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerGet.ts"],"names":[],"mappings":";;;AAkBA,4CAKC;AArBD,mDAAwD;AACxD,qDAAoD;AAEvC,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,YAAY;IAClB,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAU;IAC1C,WAAW,EACT,ivBAAivB;IACnvB,WAAW,EAAE,iCAAgB;CACrB,CAAC;AAOJ,KAAK,UAAU,gBAAgB,CACpC,OAAuB,EACvB,IAAoB;IAEpB,OAAO,IAAA,qCAAqB,EAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACrD,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerLock.d.ts

@@ -0,0 +1,68 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerLock";
+    readonly available_in: readonly ["onprem", "cloud"];
+    readonly description: "Lock operation. object_type required: CLASS(object_name*), PROGRAM(object_name*), INTERFACE(object_name*), FUNCTION_GROUP(object_name*), FUNCTION_MODULE(object_name*), TABLE(object_name*), STRUCTURE(object_name*), VIEW(object_name*), DOMAIN(object_name*), DATA_ELEMENT(object_name*), PACKAGE(object_name*), BEHAVIOR_DEFINITION(object_name*), BEHAVIOR_IMPLEMENTATION(object_name*), METADATA_EXTENSION(object_name*).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly super_package: {
+                readonly type: "string";
+                readonly description: "Super package context when relevant.";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional ADT session id for stateful lock flow.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Optional ADT session state container (cookies/CSRF) for stateful lock flow.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                        readonly description: "Serialized Cookie header to reuse server session.";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                        readonly description: "CSRF token to reuse server session.";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                        readonly description: "Cookie key/value map to reuse server session.";
+                    };
+                };
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Primary object name for lifecycle operation.";
+            };
+        };
+        readonly required: readonly ["object_type", "object_name"];
+    };
+};
+type HandlerLockArgs = {
+    object_type: CompactObjectType;
+    object_name: string;
+    super_package?: string;
+    session_id?: string;
+    session_state?: {
+        cookies?: string;
+        csrf_token?: string;
+        cookie_store?: Record<string, string>;
+    };
+};
+export declare function handleHandlerLock(context: HandlerContext, args: HandlerLockArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerLock.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerLock.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerLock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,eAAe,GAAG;IACrB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,eAAe;;;;;;GAgBtB"}

package/dist/src/handlers/compact/high/handleHandlerLock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerLock = handleHandlerLock;
+const handleLockObject_1 = require("../../common/low/handleLockObject");
+const compactLifecycleUtils_1 = require("./compactLifecycleUtils");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerLock',
+    available_in: ['onprem', 'cloud'],
+    description: 'Lock operation. object_type required: CLASS(object_name*), PROGRAM(object_name*), INTERFACE(object_name*), FUNCTION_GROUP(object_name*), FUNCTION_MODULE(object_name*), TABLE(object_name*), STRUCTURE(object_name*), VIEW(object_name*), DOMAIN(object_name*), DATA_ELEMENT(object_name*), PACKAGE(object_name*), BEHAVIOR_DEFINITION(object_name*), BEHAVIOR_IMPLEMENTATION(object_name*), METADATA_EXTENSION(object_name*).',
+    inputSchema: compactSchemas_1.compactLockSchema,
+};
+async function handleHandlerLock(context, args) {
+    const lowType = (0, compactLifecycleUtils_1.toLowObjectType)(args.object_type);
+    if (!lowType) {
+        throw new Error(`Lock is not supported for object_type: ${args.object_type}`);
+    }
+    return (0, handleLockObject_1.handleLockObject)(context, {
+        object_name: args.object_name,
+        object_type: lowType,
+        super_package: args.super_package,
+        session_id: args.session_id,
+        session_state: args.session_state,
+    });
+}
+//# sourceMappingURL=handleHandlerLock.js.map

package/dist/src/handlers/compact/high/handleHandlerLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerLock.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerLock.ts"],"names":[],"mappings":";;;AA0BA,8CAkBC;AA3CD,wEAAqE;AACrE,mEAA0D;AAE1D,qDAAqD;AAExC,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAU;IAC1C,WAAW,EACT,gaAAga;IACla,WAAW,EAAE,kCAAiB;CACtB,CAAC;AAcJ,KAAK,UAAU,iBAAiB,CACrC,OAAuB,EACvB,IAAqB;IAErB,MAAM,OAAO,GAAG,IAAA,uCAAe,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,0CAA0C,IAAI,CAAC,WAAW,EAAE,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,mCAAgB,EAAC,OAAO,EAAE;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,OAAO;QACpB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerProfileList.d.ts

@@ -0,0 +1,19 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerProfileList";
+    readonly available_in: readonly ["onprem"];
+    readonly description: "Runtime profiling list. object_type: not used. Required: none. Response: JSON.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+};
+export declare function handleHandlerProfileList(context: HandlerContext): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleHandlerProfileList.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerProfileList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileList.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerProfileList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;CAMlB,CAAC;AAEX,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,cAAc;;;;;;GAErE"}

package/dist/src/handlers/compact/high/handleHandlerProfileList.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerProfileList = handleHandlerProfileList;
+const handleRuntimeListProfilerTraceFiles_1 = require("../../system/readonly/handleRuntimeListProfilerTraceFiles");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerProfileList',
+    available_in: ['onprem'],
+    description: 'Runtime profiling list. object_type: not used. Required: none. Response: JSON.',
+    inputSchema: compactSchemas_1.compactProfileListSchema,
+};
+async function handleHandlerProfileList(context) {
+    return (0, handleRuntimeListProfilerTraceFiles_1.handleRuntimeListProfilerTraceFiles)(context);
+}
+//# sourceMappingURL=handleHandlerProfileList.js.map

package/dist/src/handlers/compact/high/handleHandlerProfileList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileList.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerProfileList.ts"],"names":[],"mappings":";;;AAYA,4DAEC;AAbD,mHAAgH;AAChH,qDAA4D;AAE/C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,oBAAoB;IAC1B,YAAY,EAAE,CAAC,QAAQ,CAAU;IACjC,WAAW,EACT,gFAAgF;IAClF,WAAW,EAAE,yCAAwB;CAC7B,CAAC;AAEJ,KAAK,UAAU,wBAAwB,CAAC,OAAuB;IACpE,OAAO,IAAA,yEAAmC,EAAC,OAAO,CAAC,CAAC;AACtD,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerProfileRun.d.ts

@@ -0,0 +1,109 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerProfileRun";
+    readonly available_in: readonly ["onprem"];
+    readonly description: "Runtime profiling run. object_type: not used. Required: target_type*(CLASS|PROGRAM) + class_name* for CLASS or program_name* for PROGRAM. Optional profiling flags and description. Response: JSON.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly target_type: {
+                readonly type: "string";
+                readonly enum: readonly ["CLASS", "PROGRAM"];
+                readonly description: "Profile execution target kind.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+                readonly description: "Class name for profiling.";
+            };
+            readonly program_name: {
+                readonly type: "string";
+                readonly description: "Program name for profiling.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Profiler run description.";
+            };
+            readonly all_procedural_units: {
+                readonly type: "boolean";
+                readonly description: "Trace all procedural units.";
+            };
+            readonly all_misc_abap_statements: {
+                readonly type: "boolean";
+                readonly description: "Trace miscellaneous ABAP statements.";
+            };
+            readonly all_internal_table_events: {
+                readonly type: "boolean";
+                readonly description: "Trace internal table events.";
+            };
+            readonly all_dynpro_events: {
+                readonly type: "boolean";
+                readonly description: "Trace dynpro events.";
+            };
+            readonly aggregate: {
+                readonly type: "boolean";
+                readonly description: "Aggregate profiling data.";
+            };
+            readonly explicit_on_off: {
+                readonly type: "boolean";
+                readonly description: "Use explicit on/off trace sections.";
+            };
+            readonly with_rfc_tracing: {
+                readonly type: "boolean";
+                readonly description: "Enable RFC tracing.";
+            };
+            readonly all_system_kernel_events: {
+                readonly type: "boolean";
+                readonly description: "Trace system kernel events.";
+            };
+            readonly sql_trace: {
+                readonly type: "boolean";
+                readonly description: "Enable SQL trace.";
+            };
+            readonly all_db_events: {
+                readonly type: "boolean";
+                readonly description: "Trace all DB events.";
+            };
+            readonly max_size_for_trace_file: {
+                readonly type: "number";
+                readonly description: "Maximum trace file size.";
+            };
+            readonly amdp_trace: {
+                readonly type: "boolean";
+                readonly description: "Enable AMDP tracing.";
+            };
+            readonly max_time_for_tracing: {
+                readonly type: "number";
+                readonly description: "Maximum tracing time.";
+            };
+        };
+        readonly required: readonly ["target_type"];
+    };
+};
+type HandlerProfileRunArgs = {
+    target_type: 'CLASS' | 'PROGRAM';
+    class_name?: string;
+    program_name?: string;
+    description?: string;
+    all_procedural_units?: boolean;
+    all_misc_abap_statements?: boolean;
+    all_internal_table_events?: boolean;
+    all_dynpro_events?: boolean;
+    aggregate?: boolean;
+    explicit_on_off?: boolean;
+    with_rfc_tracing?: boolean;
+    all_system_kernel_events?: boolean;
+    sql_trace?: boolean;
+    all_db_events?: boolean;
+    max_size_for_trace_file?: number;
+    amdp_trace?: boolean;
+    max_time_for_tracing?: number;
+};
+export declare function handleHandlerProfileRun(context: HandlerContext, args: HandlerProfileRunArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerProfileRun.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerProfileRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileRun.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerProfileRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,qBAAqB;;;;;;GA6C5B"}

package/dist/src/handlers/compact/high/handleHandlerProfileRun.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerProfileRun = handleHandlerProfileRun;
+const handleRuntimeRunClassWithProfiling_1 = require("../../system/readonly/handleRuntimeRunClassWithProfiling");
+const handleRuntimeRunProgramWithProfiling_1 = require("../../system/readonly/handleRuntimeRunProgramWithProfiling");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerProfileRun',
+    available_in: ['onprem'],
+    description: 'Runtime profiling run. object_type: not used. Required: target_type*(CLASS|PROGRAM) + class_name* for CLASS or program_name* for PROGRAM. Optional profiling flags and description. Response: JSON.',
+    inputSchema: compactSchemas_1.compactProfileRunSchema,
+};
+async function handleHandlerProfileRun(context, args) {
+    if (args.target_type === 'CLASS') {
+        if (!args.class_name) {
+            throw new Error('class_name is required when target_type is CLASS');
+        }
+        return (0, handleRuntimeRunClassWithProfiling_1.handleRuntimeRunClassWithProfiling)(context, {
+            class_name: args.class_name,
+            description: args.description,
+            all_procedural_units: args.all_procedural_units,
+            all_misc_abap_statements: args.all_misc_abap_statements,
+            all_internal_table_events: args.all_internal_table_events,
+            all_dynpro_events: args.all_dynpro_events,
+            aggregate: args.aggregate,
+            explicit_on_off: args.explicit_on_off,
+            with_rfc_tracing: args.with_rfc_tracing,
+            all_system_kernel_events: args.all_system_kernel_events,
+            sql_trace: args.sql_trace,
+            all_db_events: args.all_db_events,
+            max_size_for_trace_file: args.max_size_for_trace_file,
+            amdp_trace: args.amdp_trace,
+            max_time_for_tracing: args.max_time_for_tracing,
+        });
+    }
+    if (!args.program_name) {
+        throw new Error('program_name is required when target_type is PROGRAM');
+    }
+    return (0, handleRuntimeRunProgramWithProfiling_1.handleRuntimeRunProgramWithProfiling)(context, {
+        program_name: args.program_name,
+        description: args.description,
+        all_procedural_units: args.all_procedural_units,
+        all_misc_abap_statements: args.all_misc_abap_statements,
+        all_internal_table_events: args.all_internal_table_events,
+        all_dynpro_events: args.all_dynpro_events,
+        aggregate: args.aggregate,
+        explicit_on_off: args.explicit_on_off,
+        with_rfc_tracing: args.with_rfc_tracing,
+        all_system_kernel_events: args.all_system_kernel_events,
+        sql_trace: args.sql_trace,
+        all_db_events: args.all_db_events,
+        max_size_for_trace_file: args.max_size_for_trace_file,
+        amdp_trace: args.amdp_trace,
+        max_time_for_tracing: args.max_time_for_tracing,
+    });
+}
+//# sourceMappingURL=handleHandlerProfileRun.js.map

package/dist/src/handlers/compact/high/handleHandlerProfileRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileRun.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerProfileRun.ts"],"names":[],"mappings":";;;AAiCA,0DA+CC;AA/ED,iHAA8G;AAC9G,qHAAkH;AAClH,qDAA2D;AAE9C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,mBAAmB;IACzB,YAAY,EAAE,CAAC,QAAQ,CAAU;IACjC,WAAW,EACT,qMAAqM;IACvM,WAAW,EAAE,wCAAuB;CAC5B,CAAC;AAsBJ,KAAK,UAAU,uBAAuB,CAC3C,OAAuB,EACvB,IAA2B;IAE3B,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QACD,OAAO,IAAA,uEAAkC,EAAC,OAAO,EAAE;YACjD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;YACvD,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;YACvD,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;SAChD,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,IAAA,2EAAoC,EAAC,OAAO,EAAE;QACnD,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;QAC/C,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;QACvD,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;QACzD,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;QACzC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,eAAe,EAAE,IAAI,CAAC,eAAe;QACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;QACvC,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;QACvD,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;QACrD,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;KAChD,CAAC,CAAC;AACL,CAAC"}