@aws/lsp-codewhisperer 0.0.114 → 0.0.116

package/out/language-server/netTransform/atxTransformHandlerLegacy.js

@@ -0,0 +1,1209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtxTransformHandlerLegacy = void 0;
+const path = require("path");
+const artifactManager_1 = require("./artifactManager");
+const elastic_gumby_frontend_client_1 = require("@amazon/elastic-gumby-frontend-client");
+const AtxTokenServiceManager_1 = require("../../shared/amazonQServiceManager/AtxTokenServiceManager");
+const constants_1 = require("../../shared/constants");
+const uuid_1 = require("uuid");
+const utils_1 = require("./utils");
+/**
+ * ATX Transform Handler - Business logic for ATX FES Transform operations
+ * Parallel to RTS TransformHandler but uses AtxTokenServiceManager and ATX FES APIs
+ */
+class AtxTransformHandlerLegacy {
+    serviceManager;
+    workspace;
+    logging;
+    runtime;
+    atxClient = null;
+    cachedHitl = null;
+    constructor(serviceManager, workspace, logging, runtime) {
+        this.serviceManager = serviceManager;
+        this.workspace = workspace;
+        this.logging = logging;
+        this.runtime = runtime;
+        this.serviceManager.registerCacheCallback(() => this.onProfileUpdate());
+    }
+    /**
+     * Initialize ATX FES client
+     */
+    async initializeAtxClient() {
+        try {
+            this.logging.log('ATX: Starting client initialization');
+            let region = process.env[constants_1.ATX_FES_REGION_ENV_VAR];
+            if (!region) {
+                // Try to get region from active profile
+                region = await this.getRegionFromProfile();
+                if (!region) {
+                    this.logging.error('ATX: No region available - cannot initialize client');
+                    return false;
+                }
+            }
+            const endpoint = process.env.TCP_ENDPOINT || (0, constants_1.getAtxEndPointByRegion)(region);
+            this.logging.log(`ATX: Using region ${region} with endpoint ${endpoint}`);
+            this.atxClient = new elastic_gumby_frontend_client_1.ElasticGumbyFrontendClient({
+                region: region,
+                endpoint: endpoint,
+            });
+            this.logging.log('ATX: Client initialization completed');
+            return true;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to initialize client: ${String(error)}`);
+            return false;
+        }
+    }
+    async getRegionFromProfile() {
+        try {
+            if (!this.serviceManager.hasValidCredentials()) {
+                return undefined;
+            }
+            // Get active profile applicationURL and extract region from it
+            const atxServiceManager = AtxTokenServiceManager_1.AtxTokenServiceManager.getInstance();
+            const applicationUrl = atxServiceManager.getActiveApplicationUrl();
+            if (applicationUrl) {
+                // Extract region from applicationURL: https://xxx.transform.REGION.on.aws
+                const urlMatch = applicationUrl.match(/\.transform(?:-gamma)?\.([^.]+)\.on\.aws/);
+                if (urlMatch && urlMatch[1]) {
+                    return urlMatch[1];
+                }
+            }
+            return constants_1.DEFAULT_ATX_FES_REGION;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Error getting region from profile: ${String(error)}`);
+            return undefined;
+        }
+    }
+    /**
+     * Add bearer token and Origin header to ATX FES commands
+     */
+    async addAuthToCommand(command) {
+        if (!this.serviceManager.isReady()) {
+            throw new Error('Please select a valid Transform profile to continue');
+        }
+        const bearerToken = await this.serviceManager.getBearerToken();
+        const applicationUrl = await this.getActiveTransformProfileApplicationUrl();
+        command.middlewareStack?.add((next) => async (args) => {
+            if (!args.request.headers) {
+                args.request.headers = {};
+            }
+            args.request.headers['Authorization'] = `Bearer ${bearerToken}`;
+            // Add test classification header if running in test mode
+            const testId = process.env.ATX_TEST_ID;
+            if (testId) {
+                args.request.headers['x-amzn-qt-test-id'] = testId;
+            }
+            if (applicationUrl) {
+                const cleanOrigin = applicationUrl.endsWith('/') ? applicationUrl.slice(0, -1) : applicationUrl;
+                args.request.headers['Origin'] = cleanOrigin;
+            }
+            args.request.headers['Content-Type'] = 'application/json; charset=UTF-8';
+            args.request.headers['Content-Encoding'] = 'amz-1.0';
+            return next(args);
+        }, {
+            step: 'build',
+            name: 'addAtxAuthMiddleware',
+            priority: 'high',
+        });
+    }
+    /**
+     * Gets the applicationUrl for the active Transform profile with caching
+     */
+    async getActiveTransformProfileApplicationUrl() {
+        try {
+            // Get applicationUrl from service manager (cached from configuration)
+            const applicationUrl = this.serviceManager.getActiveApplicationUrl();
+            if (!applicationUrl) {
+                this.logging.error('ATX: No applicationUrl found - profile not selected');
+                return null;
+            }
+            return applicationUrl;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Error getting applicationUrl: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Reset atx client (for profile update scenarios)
+     */
+    onProfileUpdate() {
+        this.atxClient = null;
+    }
+    /**
+     * Verify session (internal LSP method called before each ATX API)
+     */
+    async verifySession() {
+        try {
+            if (!(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for session verification');
+                return false;
+            }
+            // Verify authentication details
+            await this.serviceManager.getBearerToken();
+            await this.getActiveTransformProfileApplicationUrl();
+            return true;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Session verification error: ${String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * List available workspaces
+     */
+    async listWorkspaces() {
+        try {
+            this.logging.log('ATX: Starting ListWorkspaces operation');
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const { ListWorkspacesCommand } = await Promise.resolve().then(() => require('@amazon/elastic-gumby-frontend-client'));
+            const command = new ListWorkspacesCommand({});
+            await this.addAuthToCommand(command);
+            const response = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListWorkspaces completed - found ${response.items?.length || 0} workspaces`);
+            this.logging.log(`ATX: ListWorkspaces RequestId: ${response.$metadata?.requestId}`);
+            // Convert ATX API format to IDE expected format
+            const workspaces = (response.items || []).map(workspace => ({
+                Id: workspace.id,
+                Name: workspace.name,
+                CreatedDate: new Date().toISOString(), // Use current date since createdDate not available
+            }));
+            return workspaces;
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListWorkspaces error: ${String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * Create a new workspace
+     */
+    async createWorkspace(workspaceName) {
+        try {
+            this.logging.log(`ATX: Starting CreateWorkspace with name: ${workspaceName || 'auto-generated'}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const { CreateWorkspaceCommand } = await Promise.resolve().then(() => require('@amazon/elastic-gumby-frontend-client'));
+            const command = new CreateWorkspaceCommand({
+                name: workspaceName || undefined,
+                description: workspaceName ? `Workspace: ${workspaceName}` : 'Auto-generated workspace',
+            });
+            await this.addAuthToCommand(command);
+            const response = await this.atxClient.send(command);
+            this.logging.log(`ATX: CreateWorkspace RequestId: ${response.$metadata?.requestId}`);
+            if (response.workspace?.id && response.workspace?.name) {
+                const result = {
+                    workspaceId: response.workspace.id,
+                    workspaceName: response.workspace.name,
+                };
+                this.logging.log(`ATX: CreateWorkspace completed successfully: ${response.workspace.id}`);
+                return result;
+            }
+            this.logging.error('ATX: CreateWorkspace failed - no workspace in response');
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: CreateWorkspace error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * List workspaces and optionally create new workspace (CONSOLIDATED API)
+     */
+    async listOrCreateWorkspace(request) {
+        try {
+            this.logging.log('ATX: Starting ListOrCreateWorkspace operation');
+            // Call verifySession ONCE at the beginning
+            if (!(await this.verifySession())) {
+                this.logging.error('ATX: Session verification failed for listOrCreateWorkspace');
+                return null;
+            }
+            // Always get list of existing workspaces
+            const workspaces = await this.listWorkspaces();
+            const response = {
+                AvailableWorkspaces: workspaces,
+                CreatedWorkspace: undefined,
+            };
+            // Optionally create new workspace
+            if (request.CreateWorkspaceName !== undefined) {
+                const newWorkspace = await this.createWorkspace(request.CreateWorkspaceName);
+                if (newWorkspace) {
+                    response.CreatedWorkspace = {
+                        WorkspaceId: newWorkspace.workspaceId,
+                        WorkspaceName: newWorkspace.workspaceName,
+                    };
+                    // Add the new workspace to the available list
+                    response.AvailableWorkspaces.push({
+                        Id: newWorkspace.workspaceId,
+                        Name: newWorkspace.workspaceName,
+                        CreatedDate: new Date().toISOString(),
+                    });
+                }
+            }
+            this.logging.log(`ATX: ListOrCreateWorkspace completed - ${response.AvailableWorkspaces.length} workspaces available`);
+            return response;
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListOrCreateWorkspace error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Create ATX transformation job
+     */
+    async createJob(request) {
+        try {
+            this.logging.log(`ATX: Starting CreateJob for workspace: ${request.workspaceId}`);
+            // Call ATX FES createJob API
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.CreateJobCommand({
+                workspaceId: request.workspaceId,
+                objective: JSON.stringify({ target_framework: request.targetFramework || 'net10.0' }),
+                jobType: 'DOTNET_IDE',
+                jobName: request.jobName || `transform-job-${Date.now()}`,
+                intent: 'LANGUAGE_UPGRADE',
+                idempotencyToken: (0, uuid_1.v4)(),
+            });
+            await this.addAuthToCommand(command);
+            const response = (await this.atxClient.send(command));
+            this.logging.log(`ATX: CreateJob completed - jobId: ${response.jobId}, status: ${response.status}`);
+            this.logging.log(`ATX: CreateJob RequestId: ${response.$metadata?.requestId}`);
+            if (response.jobId && response.status) {
+                return { jobId: response.jobId, status: response.status };
+            }
+            this.logging.error('ATX: CreateJob failed - no jobId or status in response');
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: CreateJob error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Create artifact upload URL
+     */
+    async createArtifactUploadUrl(workspaceId, jobId, filePath, categoryType, fileType) {
+        try {
+            this.logging.log(`ATX: Starting CreateArtifactUploadUrl for job: ${jobId}`);
+            // Initialize ATX client
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            // Calculate file checksum - exact reference repo implementation
+            const sha256 = await utils_1.Utils.getSha256Async(filePath);
+            const command = new elastic_gumby_frontend_client_1.CreateArtifactUploadUrlCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                contentDigest: { Sha256: sha256 },
+                artifactReference: {
+                    artifactType: {
+                        categoryType: categoryType,
+                        fileType: fileType,
+                    },
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = (await this.atxClient.send(command));
+            this.logging.log(`ATX: CreateArtifactUploadUrl RequestId: ${result.$metadata?.requestId}`);
+            if (result && result.artifactId && result.s3PreSignedUrl) {
+                this.logging.log(`ATX: CreateArtifactUploadUrl completed successfully`);
+                return {
+                    uploadId: result.artifactId,
+                    uploadUrl: result.s3PreSignedUrl,
+                    requestHeaders: result.requestHeaders,
+                };
+            }
+            else {
+                this.logging.error('ATX: CreateArtifactUploadUrl failed - missing artifactId or s3PreSignedUrl');
+                return null;
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: CreateArtifactUploadUrl error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Complete artifact upload
+     */
+    async completeArtifactUpload(workspaceId, jobId, artifactId) {
+        try {
+            this.logging.log(`ATX: Starting CompleteArtifactUpload for artifact: ${artifactId}`);
+            // Initialize ATX client
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.CompleteArtifactUploadCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                artifactId: artifactId,
+            });
+            await this.addAuthToCommand(command);
+            const result = (await this.atxClient.send(command));
+            this.logging.log(`ATX: CompleteArtifactUpload completed successfully`);
+            return { success: true };
+        }
+        catch (error) {
+            this.logging.error(`ATX: CompleteArtifactUpload error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Start transformation job
+     */
+    async startJob(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: Starting job: ${jobId}`);
+            // Initialize ATX client
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.StartJobCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+            });
+            await this.addAuthToCommand(command);
+            const result = (await this.atxClient.send(command));
+            this.logging.log(`ATX: StartJob RequestId: ${result.$metadata?.requestId}`);
+            this.logging.log(`ATX: Job started successfully`);
+            return { success: true };
+        }
+        catch (error) {
+            this.logging.error(`ATX: StartJob error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Create ZIP file from solution using ArtifactManager
+     */
+    async createZip(request) {
+        try {
+            this.logging.log('ATX: Starting ZIP file creation from solution');
+            const workspacePath = utils_1.Utils.getWorkspacePath(request.SolutionRootPath);
+            const artifactManager = new artifactManager_1.ArtifactManager(this.workspace, this.logging, workspacePath, request.SolutionRootPath);
+            const zipFilePath = await artifactManager.createZip(request);
+            this.logging.log(`ATX: ZIP file created successfully: ${zipFilePath}`);
+            return zipFilePath;
+        }
+        catch (error) {
+            this.logging.error(`ATX: createZip error: ${String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Start ATX Transform - Orchestrates the full workflow
+     * Step 1: CreateJob ✅
+     * Step 2: ZIP Creation and Upload
+     */
+    async startTransform(request) {
+        try {
+            this.logging.log(`ATX: Starting transform workflow for workspace: ${request.workspaceId}`);
+            // Step 1: Create transformation job
+            const createJobResponse = await this.createJob({
+                workspaceId: request.workspaceId,
+                jobName: request.jobName || 'Transform Job',
+                targetFramework: request.startTransformRequest.TargetFramework,
+            });
+            if (!createJobResponse?.jobId) {
+                throw new Error('Failed to create ATX transformation job');
+            }
+            // Step 2: Create ZIP file
+            const zipFilePath = await this.createZip(request.startTransformRequest);
+            if (!zipFilePath) {
+                throw new Error('Failed to create ZIP file for ATX transformation');
+            }
+            // Step 3: Create artifact upload URL
+            const uploadResponse = await this.createArtifactUploadUrl(request.workspaceId, createJobResponse.jobId, zipFilePath, elastic_gumby_frontend_client_1.CategoryType.CUSTOMER_INPUT, elastic_gumby_frontend_client_1.FileType.ZIP);
+            if (!uploadResponse?.uploadUrl) {
+                throw new Error('Failed to create artifact upload URL');
+            }
+            // Step 4: Upload ZIP file to S3
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadResponse.uploadUrl, zipFilePath, uploadResponse.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                throw new Error('Failed to upload ZIP file to S3');
+            }
+            // Step 5: Complete artifact upload
+            const completeResponse = await this.completeArtifactUpload(request.workspaceId, createJobResponse.jobId, uploadResponse.uploadId);
+            if (!completeResponse?.success) {
+                throw new Error('Failed to complete artifact upload');
+            }
+            // Step 6: Start the transformation job
+            const startJobResponse = await this.startJob(request.workspaceId, createJobResponse.jobId);
+            if (!startJobResponse?.success) {
+                throw new Error('Failed to start ATX transformation job');
+            }
+            this.logging.log('ATX: Transform workflow completed successfully');
+            return {
+                TransformationJobId: createJobResponse.jobId,
+                ArtifactPath: zipFilePath,
+                UploadId: uploadResponse.uploadId,
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: StartTransform workflow error: ${String(error)}`);
+            return null;
+        }
+    }
+    async getJob(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: Getting job: ${jobId} in workspace: ${workspaceId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: GetJob client not initialized');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.GetJobCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                includeObjective: false,
+            });
+            await this.addAuthToCommand(command);
+            const response = await this.atxClient.send(command);
+            this.logging.log(`ATX: GetJob completed - Job status: ${response.job?.statusDetails?.status}`);
+            return response.job || null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: GetJob error: ${String(error)}`);
+            return null;
+        }
+    }
+    async createArtifactDownloadUrl(workspaceId, jobId, artifactId) {
+        try {
+            this.logging.log(`ATX: Starting CreateArtifactDownloadUrl for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.CreateArtifactDownloadUrlCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                artifactId: artifactId,
+            });
+            await this.addAuthToCommand(command);
+            const result = (await this.atxClient.send(command));
+            if (result && result.s3PreSignedUrl) {
+                this.logging.log(`ATX: CreateArtifactDownloadUrl completed successfully`);
+                const normalizedHeaders = {};
+                if (result.requestHeaders) {
+                    for (const [key, value] of Object.entries(result.requestHeaders)) {
+                        normalizedHeaders[key] = Array.isArray(value) ? value[0] : value;
+                    }
+                }
+                return {
+                    s3PresignedUrl: result.s3PreSignedUrl,
+                    requestHeaders: normalizedHeaders,
+                };
+            }
+            else {
+                this.logging.error('ATX: CreateArtifactDownloadUrl failed - missing s3PreSignedUrl');
+                return null;
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: CreateArtifactDownloadUrl error: ${String(error)}`);
+            return null;
+        }
+    }
+    async listHitls(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: Starting ListHitls for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListHitls');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                taskType: 'NORMAL',
+                taskFilter: {
+                    taskStatuses: ['AWAITING_HUMAN_INPUT'],
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListHitls completed - Found ${result.hitlTasks?.length || 0} tasks`);
+            return result.hitlTasks || [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListHitls error: ${String(error)}`);
+            return null;
+        }
+    }
+    async submitHitl(workspaceId, jobId, taskId, humanArtifactId) {
+        try {
+            this.logging.log(`ATX: Starting SubmitHitl for task: ${taskId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for SubmitHitl');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.SubmitCriticalHitlTaskCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                taskId: taskId,
+                action: 'APPROVE',
+                humanArtifact: {
+                    artifactId: humanArtifactId,
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: SubmitHitl completed - task status: ${result.status || 'UNKNOWN'}`);
+            return result;
+        }
+        catch (error) {
+            this.logging.error(`ATX: SubmitHitl error: ${String(error)}`);
+            return null;
+        }
+    }
+    async getHitl(workspaceId, jobId, taskId) {
+        try {
+            this.logging.log(`ATX: Getting Hitl task: ${taskId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for GetHitl');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.GetHitlTaskCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                taskId: taskId,
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: GetHitl completed successfully`);
+            return result.task || null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: GetHitl error: ${String(error)}`);
+            return null;
+        }
+    }
+    async pollHitlTask(workspaceId, jobId, taskId) {
+        this.logging.log('ATX: Starting polling for hitl after upload');
+        try {
+            var count = 0;
+            while (count < 100) {
+                const jobStatus = await this.getHitl(workspaceId, jobId, taskId);
+                this.logging.log(`ATX: Hitl polling status: ${jobStatus?.status}`);
+                if (jobStatus && jobStatus.status == 'CLOSED') {
+                    return 'Validation Success!';
+                }
+                else if (jobStatus && jobStatus.status == 'CLOSED_PENDING_NEXT_TASK') {
+                    return 'Submitted plan did not pass validation, please check the plan for details....';
+                }
+                else if (jobStatus && jobStatus.status == 'CANCELLED') {
+                    return 'Timeout occured during planning, proceeding with default plan....';
+                }
+                else {
+                    await utils_1.Utils.sleep(10 * 1000);
+                    count++;
+                }
+            }
+            this.logging.log('ATX: Hitl polling timeout after 100 attempts');
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Hitl polling error: ${String(error)}`);
+            return null;
+        }
+    }
+    async getHitlAgentArtifact(workspaceId, jobId, solutionRootPath) {
+        try {
+            this.logging.log(`ATX: Getting Hitl Agent Artifact for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for GetHitlAgentArtifact');
+                return null;
+            }
+            const hitls = await this.listHitls(workspaceId, jobId);
+            if (!hitls || hitls.length === 0) {
+                this.logging.log(`ATX: No hitls available`);
+                return null;
+            }
+            if (hitls.length != 1) {
+                this.logging.log(`ATX: Found ${hitls.length} hitls (expected 1)`);
+            }
+            const hitl = hitls[0];
+            this.cachedHitl = hitl.taskId;
+            const hitlTag = hitl.tag || null;
+            const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, hitl.agentArtifact.artifactId);
+            if (!downloadInfo) {
+                throw new Error('Failed to get ATX FES download URL');
+            }
+            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
+            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'transformation-plan-download.zip', this.logging);
+            const fs = require('fs');
+            const extractedFiles = fs.readdirSync(pathToDownload);
+            this.logging.log(`ATX: Extracted files in ${pathToDownload}: ${JSON.stringify(extractedFiles)}`);
+            const planPath = path.join(pathToDownload, 'transformation-plan.md');
+            const reportPath = path.join(pathToDownload, 'assessment-report.md');
+            const missingPackageJsonPath = path.join(pathToDownload, 'missing-packages.json');
+            this.logging.log(`ATX: GetHitlAgentArtifact completed successfully`);
+            return {
+                PlanPath: fs.existsSync(planPath) ? planPath : undefined,
+                ReportPath: fs.existsSync(reportPath) ? reportPath : undefined,
+                MissingPackageJsonPath: fs.existsSync(missingPackageJsonPath) ? missingPackageJsonPath : undefined,
+                HitlTag: hitlTag,
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: GetHitlAgentArtifact error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Get transform info - dummy implementation
+     */
+    async getTransformInfo(request) {
+        try {
+            this.logging.log(`ATX: Getting transform info for job: ${request.TransformationJobId}`);
+            const job = await this.getJob(request.WorkspaceId, request.TransformationJobId);
+            if (!job) {
+                this.logging.error(`ATX: Job not found: ${request.TransformationJobId}`);
+                return null;
+            }
+            const jobStatus = job.statusDetails?.status;
+            if (jobStatus === 'COMPLETED') {
+                const pathToArtifact = await this.downloadFinalArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                    },
+                    ArtifactPath: pathToArtifact,
+                    TransformationPlan: plan,
+                };
+            }
+            else if (jobStatus === 'FAILED') {
+                this.logging.error(`ATX: Job failed - Reason: ${job?.statusDetails?.failureReason ?? 'Unknown'}`);
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                        FailureReason: job?.statusDetails?.failureReason,
+                    },
+                    ErrorString: 'Transformation job failed',
+                };
+            }
+            else if (jobStatus === 'STOPPING' || jobStatus === 'STOPPED') {
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                    },
+                    ErrorString: 'Transformation job stopped',
+                };
+            }
+            else if (jobStatus === 'PLANNED') {
+                const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                    },
+                    TransformationPlan: plan,
+                };
+            }
+            else if (jobStatus === 'AWAITING_HUMAN_INPUT') {
+                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                this.logging.log(`ATX: HITL full response: ${JSON.stringify(response)}`);
+                this.logging.log(`ATX: HITL response - HitlTag: ${response?.HitlTag}, MissingPackageJsonPath: ${response?.MissingPackageJsonPath}`);
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                    },
+                    PlanPath: response?.PlanPath,
+                    ReportPath: response?.ReportPath,
+                    MissingPackageJsonPath: response?.MissingPackageJsonPath,
+                    HitlTag: response?.HitlTag,
+                };
+            }
+            else {
+                await this.listWorklogs(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: jobStatus,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: GetTransformInfo error: ${String(error)}`);
+            return null;
+        }
+    }
+    async uploadPlan(request) {
+        this.logging.log('ATX: Starting upload plan');
+        if (!this.cachedHitl) {
+            this.logging.error('ATX: UploadPlan error: No cached hitl');
+            return null;
+        }
+        try {
+            const pathToZip = path.join(path.dirname(request.PlanPath), 'transformation-plan-upload.zip');
+            await utils_1.Utils.zipFile(request.PlanPath, pathToZip);
+            const uploadInfo = await this.createArtifactUploadUrl(request.WorkspaceId, request.TransformationJobId, pathToZip, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
+            if (!uploadInfo) {
+                this.logging.error('ATX: UploadPlan error: Failed to get upload URL');
+                return null;
+            }
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, pathToZip, uploadInfo.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                throw new Error('Failed to upload ZIP file to S3');
+            }
+            const completeResponse = await this.completeArtifactUpload(request.WorkspaceId, request.TransformationJobId, uploadInfo.uploadId);
+            if (!completeResponse?.success) {
+                throw new Error('Failed to complete artifact upload');
+            }
+            this.logging.log('ATX: Plan uploaded, submitting hitl');
+            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, uploadInfo.uploadId);
+            if (!submitHitl) {
+                throw new Error('Failed to submit hitl');
+            }
+            this.logging.log('ATX: Hitl submitted, polling for status');
+            const validation = await this.pollHitlTask(request.WorkspaceId, request.TransformationJobId, this.cachedHitl);
+            if (!validation) {
+                throw new Error('Failed to poll hitl task');
+            }
+            if (validation === 'Submitted plan did not pass validation, please check the plan for details....') {
+                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, path.dirname(path.dirname(path.dirname(request.PlanPath))));
+                return {
+                    VerificationStatus: false,
+                    Message: validation,
+                    PlanPath: response?.PlanPath,
+                    ReportPath: response?.ReportPath,
+                };
+            }
+            else {
+                return {
+                    VerificationStatus: true,
+                    Message: validation,
+                };
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: UploadPlan error: ${String(error)}`);
+            return null;
+        }
+    }
+    // Upload Missing package dependencies
+    async uploadPackages(request) {
+        this.logging.log('ATX: Starting upload packages');
+        if (!this.cachedHitl) {
+            this.logging.error('ATX: UploadPackages error: No cached hitl');
+            return { Success: false, Message: 'No cached HITL task' };
+        }
+        try {
+            if (!request.PackagesZipPath) {
+                this.logging.log('ATX: No packages to upload, submitting HITL without artifact');
+                return { Success: false, Message: "No Package xip path found. Can't proceed with HITL" };
+            }
+            var humanArtifactId = await this.uploadArtifactAndComplete(request.WorkspaceId, request.TransformationJobId, request.PackagesZipPath);
+            if (!humanArtifactId) {
+                return { Success: false, Message: 'Failed to upload packages' };
+            }
+            this.logging.log('ATX: Packages uploaded successfully');
+            // Submit HITL (with or without artifact)
+            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, humanArtifactId);
+            if (!submitHitl) {
+                throw new Error('Failed to submit hitl');
+            }
+            this.logging.log('ATX: HITL submitted successfully');
+            return {
+                Success: true,
+                Message: 'Packages uploaded and HITL submitted successfully',
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: UploadPackages error: ${String(error)}`);
+            return { Success: false, Message: String(error) };
+        }
+    }
+    async uploadArtifactAndComplete(workspaceId, jobId, filePath) {
+        const uploadInfo = await this.createArtifactUploadUrl(workspaceId, jobId, filePath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
+        if (!uploadInfo) {
+            this.logging.error('ATX: Failed to get upload URL');
+            return null;
+        }
+        const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, filePath, uploadInfo.requestHeaders, this.logging);
+        if (!uploadSuccess) {
+            this.logging.error('ATX: Failed to upload to S3');
+            return null;
+        }
+        const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadInfo.uploadId);
+        if (!completeResponse?.success) {
+            this.logging.error('ATX: Failed to complete artifact upload');
+            return null;
+        }
+        return uploadInfo.uploadId;
+    }
+    /**
+     * Stop ATX transformation job
+     */
+    async stopJob(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: StopJob operation started for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.StopJobCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+            });
+            await this.addAuthToCommand(command);
+            const response = await this.atxClient.send(command);
+            this.logging.log(`ATX: StopJob SUCCESS - Status: ${response.status}`);
+            this.logging.log(`ATX: StopJob RequestId: ${response.$metadata?.requestId}`);
+            return response.status || 'STOPPED';
+        }
+        catch (error) {
+            this.logging.error(`ATX: StopJob error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return 'FAILED';
+        }
+    }
+    async downloadFinalArtifact(workspaceId, jobId, solutionRootPath) {
+        try {
+            this.logging.log(`ATX: Starting download final artifact for job: ${jobId}`);
+            const artifacts = await this.listArtifacts(workspaceId, jobId);
+            if (!artifacts || artifacts.length === 0) {
+                throw new Error('No CUSTOMER_OUTPUT artifacts available for download');
+            }
+            const artifact = artifacts[0];
+            const artifactId = artifact.artifactId;
+            this.logging.log(`ATX: Found artifact: ${artifactId}, size: ${artifact.sizeInBytes} bytes`);
+            const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, artifactId);
+            if (!downloadInfo) {
+                throw new Error('Failed to get ATX FES download URL');
+            }
+            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
+            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'ExportResultsArchive.zip', this.logging);
+            this.logging.log(`ATX: Download final artifact completed successfully`);
+            return pathToDownload;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Download final artifact failed: ${String(error)}`);
+            return null;
+        }
+    }
+    async getTransformationPlan(workspaceId, jobId, solutionRootPath) {
+        try {
+            // Get real plan steps from ATX FES (only if job status >= PLANNED)
+            const planSteps = await this.getATXFESJobPlanSteps(workspaceId, jobId);
+            if (planSteps) {
+                this.logging.log(`ATX FES: Found ${planSteps.length} transformation steps`);
+                // Sort steps by score (primary) and startTime (tiebreaker) to match RTS ordering
+                planSteps.sort((a, b) => {
+                    const scoreDiff = (a.score || 0) - (b.score || 0);
+                    if (scoreDiff !== 0)
+                        return scoreDiff;
+                    // Tiebreaker for identical scores: sort by startTime
+                    const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
+                    const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
+                    return timeA - timeB;
+                });
+                // Return in exact same format as RTS with all required fields
+                const transformationPlan = {
+                    transformationSteps: planSteps.map((step, index) => {
+                        try {
+                            // Map substeps to ProgressUpdates for IDE display
+                            const progressUpdates = (step.substeps || []).map((substep) => {
+                                // Map ATX substep status to IDE TransformationProgressUpdateStatus enum values
+                                let substepStatus = 'IN_PROGRESS'; // Default - no NOT_STARTED in this enum
+                                switch (substep.status) {
+                                    case 'SUCCEEDED':
+                                    case 'COMPLETED':
+                                        substepStatus = 'COMPLETED';
+                                        break;
+                                    case 'IN_PROGRESS':
+                                    case 'RUNNING':
+                                        substepStatus = 'IN_PROGRESS';
+                                        break;
+                                    case 'FAILED':
+                                        substepStatus = 'FAILED';
+                                        break;
+                                    case 'SKIPPED':
+                                        substepStatus = 'SKIPPED';
+                                        break;
+                                    case 'NOT_STARTED':
+                                    case 'CREATED':
+                                    default:
+                                        substepStatus = 'IN_PROGRESS'; // No NOT_STARTED option in ProgressUpdate enum
+                                        break;
+                                }
+                                // Map nested progress updates (3rd level)
+                                const nestedProgressUpdates = (substep.substeps || []).map((nestedUpdate) => {
+                                    let nestedStatus = 'IN_PROGRESS';
+                                    switch (nestedUpdate.status) {
+                                        case 'SUCCEEDED':
+                                        case 'COMPLETED':
+                                            nestedStatus = 'COMPLETED';
+                                            break;
+                                        case 'IN_PROGRESS':
+                                        case 'RUNNING':
+                                            nestedStatus = 'IN_PROGRESS';
+                                            break;
+                                        case 'FAILED':
+                                            nestedStatus = 'FAILED';
+                                            break;
+                                        case 'SKIPPED':
+                                            nestedStatus = 'SKIPPED';
+                                            break;
+                                        default:
+                                            nestedStatus = 'IN_PROGRESS';
+                                            break;
+                                    }
+                                    return {
+                                        name: nestedUpdate.stepName || 'Unknown Nested Update',
+                                        description: nestedUpdate.description || '',
+                                        status: nestedStatus,
+                                        stepId: nestedUpdate.stepId ?? undefined,
+                                    };
+                                });
+                                return {
+                                    name: substep.stepName || 'Unknown Substep',
+                                    description: substep.description || '',
+                                    status: substepStatus,
+                                    startTime: substep.startTime ? new Date(substep.startTime) : undefined,
+                                    endTime: substep.endTime ? new Date(substep.endTime) : undefined,
+                                    stepId: substep.stepId ?? undefined,
+                                    progressUpdates: nestedProgressUpdates,
+                                };
+                            });
+                            // Use ATX status directly - IDE supports most values, minimal mapping needed
+                            let mappedStatus = step.status || 'NOT_STARTED';
+                            // Only map the few values IDE doesn't have
+                            if (mappedStatus === 'SUCCEEDED') {
+                                mappedStatus = 'COMPLETED';
+                            }
+                            else if (mappedStatus === 'RUNNING') {
+                                mappedStatus = 'IN_PROGRESS';
+                            }
+                            else if (mappedStatus === 'CREATED') {
+                                mappedStatus = 'NOT_STARTED';
+                            }
+                            // Use ATX step data directly without hardcoded ordering
+                            const stepNumber = index + 1;
+                            const stepName = `Step ${stepNumber} - ${step.stepName || 'Unknown Step'}`;
+                            return {
+                                id: step.stepId || `step-${stepNumber}`,
+                                name: stepName,
+                                description: step.description || '',
+                                status: mappedStatus,
+                                progressUpdates: progressUpdates,
+                                startTime: step.startTime ? new Date(step.startTime) : undefined,
+                                endTime: step.endTime ? new Date(step.endTime) : undefined,
+                            };
+                        }
+                        catch (error) {
+                            this.logging.error(`ATX FES: Error mapping step ${index}: ${String(error)}`);
+                            // Return a safe fallback step
+                            const stepNumber = index + 1;
+                            return {
+                                id: step.stepId || `fallback-${stepNumber}`,
+                                name: `Step ${stepNumber} - ${step.stepName || `Step ${stepNumber}`}`,
+                                description: step.description || '',
+                                status: 'NOT_STARTED',
+                                progressUpdates: [],
+                                startTime: undefined,
+                                endTime: undefined,
+                            };
+                        }
+                    }),
+                };
+                try {
+                    await this.listWorklogs(workspaceId, jobId, solutionRootPath);
+                }
+                catch (e) {
+                    this.logging.log(`ATX FES: Could not get worklog for workspaces: ${workspaceId}, job id: ${jobId}`);
+                }
+                this.logging.log(`ATX FES: Successfully mapped ${transformationPlan.transformationSteps?.length || 0} steps`);
+                return transformationPlan;
+            }
+            else {
+                this.logging.log('ATX FES: No plan steps available yet - returning empty plan');
+                return {
+                    transformationSteps: [],
+                };
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX FES getTransformationPlan error: ${String(error)}`);
+            // Return empty plan on error
+            return {
+                transformationSteps: [],
+            };
+        }
+    }
+    async getATXFESJobPlanSteps(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX FES: getting plan steps with substeps...`);
+            const result = await this.listJobPlanSteps(workspaceId, jobId);
+            if (result) {
+                const steps = result || [];
+                this.logging.log(`ListJobPlanSteps: SUCCESS - Found ${steps.length} plan steps with substeps`);
+                return steps;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`ListJobPlanSteps error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+    /**
+     * Lists job plan steps using FES client with recursive substep fetching
+     */
+    async listJobPlanSteps(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: Starting ListJobPlanSteps for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListJobPlanSteps');
+                return null;
+            }
+            // Get root steps first
+            const rootSteps = await this.getStepsRecursive(workspaceId, jobId, 'root');
+            if (rootSteps && rootSteps.length > 0) {
+                // For each root step, get its substeps
+                for (const step of rootSteps) {
+                    const substeps = await this.getStepsRecursive(workspaceId, jobId, step.stepId);
+                    step.substeps = substeps || [];
+                    // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
+                    if (step.substeps.length > 0) {
+                        step.substeps.sort((a, b) => {
+                            const scoreDiff = (a.score || 0) - (b.score || 0);
+                            if (scoreDiff !== 0)
+                                return scoreDiff;
+                            // Tiebreaker for identical scores: sort by startTime
+                            const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
+                            const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
+                            return timeA - timeB;
+                        });
+                        for (const substep of step.substeps) {
+                            const superSubsteps = await this.getStepsRecursive(workspaceId, jobId, substep.stepId);
+                            substep.substeps = superSubsteps || [];
+                            // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
+                            if (substep.substeps.length > 0) {
+                                substep.substeps.sort((a, b) => {
+                                    const scoreDiff = (a.score || 0) - (b.score || 0);
+                                    if (scoreDiff !== 0)
+                                        return scoreDiff;
+                                    // Tiebreaker for identical scores: sort by startTime
+                                    const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
+                                    const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
+                                    return timeA - timeB;
+                                });
+                            }
+                        }
+                    }
+                }
+                this.logging.log(`ATX: ListJobPlanSteps completed - Found ${rootSteps.length} steps with substeps`);
+                return rootSteps;
+            }
+            this.logging.log('ATX: ListJobPlanSteps - No root steps found');
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListJobPlanSteps error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Recursively gets steps for a given parent step ID
+     */
+    async getStepsRecursive(workspaceId, jobId, parentStepId) {
+        try {
+            const command = new elastic_gumby_frontend_client_1.ListJobPlanStepsCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                parentStepId: parentStepId,
+                maxResults: 100,
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            if (result && result.steps && result.steps.length > 0) {
+                return result.steps;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logging.error(`Error getting steps for parent ${parentStepId}: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Lists artifacts using FES client with filtering - default to CUSTOMER_OUTPUT
+     */
+    async listArtifacts(workspaceId, jobId, filter = 'CUSTOMER_OUTPUT') {
+        try {
+            this.logging.log(`ATX: Starting ListArtifacts for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListArtifacts');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListArtifactsCommand({
+                workspaceId: workspaceId,
+                jobFilter: {
+                    jobId: jobId,
+                    categoryType: filter, // Server-side filtering for customer output artifacts
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListArtifacts completed - Found ${result.artifacts?.length || 0} artifacts`);
+            return result.artifacts || [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+    /**
+     * Lists artifacts using FES client with CUSTOMER_OUTPUT filtering
+     */
+    async listWorklogs(workspaceId, jobId, solutionRootPath, stepId) {
+        try {
+            this.logging.log(`ATX: Starting ListWorklogs for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListWorklogs');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListWorklogsCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                ...(stepId && {
+                    worklogFilter: {
+                        stepIdFilter: {
+                            stepId: stepId,
+                        },
+                    },
+                }),
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListWorklogs completed - Found ${result.worklogs?.length || 0} entries`);
+            for (const value of result.worklogs || []) {
+                const currentStepId = value.attributeMap?.STEP_ID || stepId || 'Progress';
+                await utils_1.Utils.saveWorklogsToJson(jobId, currentStepId, value.description || '', solutionRootPath);
+            }
+            return result.worklogs || [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListWorklogs error: ${String(error)}`);
+            return null;
+        }
+    }
+}
+exports.AtxTransformHandlerLegacy = AtxTransformHandlerLegacy;
+//# sourceMappingURL=atxTransformHandlerLegacy.js.map