@turbotic/taai-agent 0.0.1

package/build/run.js

@@ -0,0 +1,1205 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const RUN_DIRECTORY = path_1.default.join(process.cwd(), 'run');
+const generate_script_1 = __importDefault(require("./generate-script"));
+const performance_now_1 = __importDefault(require("performance-now"));
+if (!fs_extra_1.default.existsSync(RUN_DIRECTORY)) {
+    fs_extra_1.default.mkdirSync(RUN_DIRECTORY, { recursive: true });
+}
+class Runner {
+    // Get the agent endpoint for internal APIs (localhost:3005)
+    // First check if script runner agent is enabled in config collection
+    // Then check if agent URL is configured in env variable
+    // Otherwise fall back to app URL
+    getAgentEndpoint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if script runner agent is enabled in config collection
+            try {
+                if (process.env.SCRIPT_RUNNER_AGENT_ENDPOINT) {
+                    return process.env.SCRIPT_RUNNER_AGENT_ENDPOINT;
+                }
+            }
+            catch (error) {
+                console.error('Error checking script runner agent config:', error);
+                // Continue to fallback logic if config check fails
+            }
+            // Fall back to app URL if agent endpoint is not configured or agent is not enabled
+            return process.env.AUTOMATIONAI_ENDPOINT || 'http://localhost:3005';
+        });
+    }
+    constructor(automationId) {
+        this.envVariables = [];
+        this.dependencies = [];
+        this.running = false;
+        this.__stdoutBuffer = '';
+        this.__stderrBuffer = '';
+        this.runtimeEnvironment = 'dev';
+        this.automationVersion = "2";
+        this.__logBuffer = [];
+        this.__killAfterLogPush = false;
+        this.__logPushPaused = false;
+        this.executionFiles = ['code.js'];
+        this.automationId = automationId;
+        this.runDirectory = path_1.default.join(RUN_DIRECTORY, automationId);
+        fs_extra_1.default.mkdirSync(this.runDirectory, { recursive: true });
+    }
+    safeJsonParse(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responseText = yield response.text();
+            // Check if response is HTML (error page)
+            if (responseText.trim().startsWith('<!DOCTYPE') || responseText.trim().startsWith('<html') || responseText.trim().startsWith('<!')) {
+                throw new Error(`Server returned HTML instead of JSON. Status: ${response.status} ${response.statusText}. This usually indicates a server error or authentication issue. Response preview: ${responseText.substring(0, 200)}`);
+            }
+            if (!responseText) {
+                throw new Error(`Empty response from server. Status: ${response.status} ${response.statusText}`);
+            }
+            if (!response.ok) {
+                throw new Error(`API call failed: ${response.status} ${response.statusText}. Response: ${responseText.substring(0, 200)}`);
+            }
+            try {
+                return JSON.parse(responseText);
+            }
+            catch (parseError) {
+                throw new Error(`Failed to parse JSON response: ${parseError.message}. Response preview: ${responseText.substring(0, 200)}`);
+            }
+        });
+    }
+    installDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.dependencies.length === 0) {
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                var _a, _b;
+                const cmd = `npm install ${this.dependencies.map((dep) => `${dep.name}@${dep.version}`).join(' ')}`;
+                console.log(cmd);
+                this._installProcess = (0, child_process_1.exec)(cmd, {
+                    cwd: this.runDirectory,
+                    env: Object.assign({}, process.env)
+                });
+                (_a = this._installProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                    console.log('stdout', data.toString());
+                    this.pushLogs(data.toString());
+                });
+                (_b = this._installProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                    console.log('stderr', data.toString());
+                    this.pushLogs(data.toString());
+                });
+                this._installProcess.on('close', (code) => {
+                    console.log(`Installation complete with exit code ${code}`);
+                    this.pushLogs(`Installation complete with exit code ${code}`);
+                    if (code > 0) {
+                        this.pushLogs(`Run complete with exit code ${code === null ? 0 : code}`);
+                    }
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Installation failed with exit code ${code}`));
+                    }
+                });
+            });
+        });
+    }
+    downloadCode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                console.log(`Current user ID:`, this.executionHistory.userId);
+                console.log(`Runtime environment:`, this.executionHistory.runtimeEnvironment || 'default');
+                const headers = {
+                    'X-Script-Runner': 'true',
+                    'User-Agent': 'TurboticAI-ScriptRunner/1.0',
+                    'X-Current-User-Id': String(this.executionHistory.userId)
+                };
+                // Pass runtime environment to get correct env var values
+                if (this.executionHistory.runtimeEnvironment) {
+                    headers['X-Runtime-Environment'] = this.executionHistory.runtimeEnvironment;
+                }
+                const response = yield fetch(`${yield this.getAgentEndpoint()}/api/automations/${this.automationId}`, {
+                    headers
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch automation: ${response.status} ${response.statusText}`);
+                }
+                const responseText = yield response.text();
+                if (!responseText) {
+                    throw new Error('Empty response from automation API');
+                }
+                let automation;
+                try {
+                    automation = JSON.parse(responseText);
+                }
+                catch (parseError) {
+                    console.error('JSON parse error. Response text:', responseText);
+                    throw new Error(`Invalid JSON response: ${parseError.message}`);
+                }
+                this.runtimeEnvironment = (automation === null || automation === void 0 ? void 0 : automation.runtimeEnvironment) || 'dev';
+                this.runFrom = ((_a = this.__queuePayload) === null || _a === void 0 ? void 0 : _a.runFrom) || undefined;
+                if ((automation === null || automation === void 0 ? void 0 : automation.version) === "3") {
+                    this.automationVersion = "3";
+                    fs_extra_1.default.emptyDirSync(this.runDirectory);
+                    let metadata = {
+                        steps: []
+                    };
+                    const executionFiles = [];
+                    if (((_b = automation === null || automation === void 0 ? void 0 : automation.v3Steps) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                        let index = 0;
+                        for (const step of automation === null || automation === void 0 ? void 0 : automation.v3Steps) {
+                            index++;
+                            const fileName = `step-${index}.js`;
+                            executionFiles.push(fileName);
+                            fs_extra_1.default.writeFileSync(path_1.default.join(this.runDirectory, fileName), (0, generate_script_1.default)(step.code || '', String(this.executionHistory.userId)));
+                            metadata.steps.push({
+                                title: step.name,
+                                fileName: fileName,
+                                stepId: step.id
+                            });
+                        }
+                    }
+                    fs_extra_1.default.writeFileSync(path_1.default.join(this.runDirectory, 'metadata.json'), JSON.stringify(metadata, null, 2));
+                    executionFiles.push('metadata.json');
+                    this.executionFiles = executionFiles;
+                    console.log('Latest code pulled');
+                }
+                else {
+                    fs_extra_1.default.mkdirSync(this.runDirectory, { recursive: true });
+                    fs_extra_1.default.writeFileSync(path_1.default.join(this.runDirectory, 'code.js'), (0, generate_script_1.default)((automation === null || automation === void 0 ? void 0 : automation.code) || '', String(this.executionHistory.userId)));
+                    console.log('Latest code pulled');
+                }
+                // Helper function to process env vars (extract multi-environment values)
+                const processEnvVars = (envVars) => {
+                    return envVars.map((envVar) => {
+                        // Handle new multi-environment structure for value
+                        if (envVar.value && typeof envVar.value === 'object' && !Array.isArray(envVar.value)) {
+                            // Check if it's the new multi-environment structure (has dev/test/production keys)
+                            if (envVar.value.dev !== undefined || envVar.value.test !== undefined || envVar.value.production !== undefined) {
+                                // Extract the appropriate environment's value
+                                let extractedValue;
+                                if (this.runtimeEnvironment === 'dev' && envVar.value.dev !== undefined) {
+                                    extractedValue = envVar.value.dev;
+                                }
+                                else if (this.runtimeEnvironment === 'test' && envVar.value.test !== undefined) {
+                                    extractedValue = envVar.value.test;
+                                }
+                                else if (this.runtimeEnvironment === 'production' && envVar.value.production !== undefined) {
+                                    extractedValue = envVar.value.production;
+                                }
+                                else {
+                                    // Fallback to first available environment
+                                    extractedValue = envVar.value.dev !== undefined ? envVar.value.dev :
+                                        (envVar.value.test !== undefined ? envVar.value.test : envVar.value.production);
+                                }
+                                return Object.assign(Object.assign({}, envVar), { value: extractedValue });
+                            }
+                        }
+                        // Old structure or already processed - return as is
+                        return envVar;
+                    });
+                };
+                // Use environment variables from queue payload if provided, otherwise use automation's env vars
+                if (((_c = this.__queuePayload) === null || _c === void 0 ? void 0 : _c.environmentVariables) && this.__queuePayload.environmentVariables.length > 0) {
+                    // Process queue payload env vars to handle old and new structures
+                    this.envVariables = processEnvVars(this.__queuePayload.environmentVariables);
+                    console.log(`Using ${this.envVariables.length} environment variables from queue payload`);
+                }
+                else if (automation === null || automation === void 0 ? void 0 : automation.environmentVariables) {
+                    // Process automation env vars to handle old and new structures
+                    this.envVariables = processEnvVars(automation.environmentVariables);
+                    console.log(`Using ${this.envVariables.length} environment variables from automation`);
+                }
+                if (automation === null || automation === void 0 ? void 0 : automation.dependencies) {
+                    this.dependencies = automation.dependencies;
+                }
+            }
+            catch (error) {
+                console.error('Error downloading code:', error);
+                // Create a default empty script to prevent complete failure
+                fs_extra_1.default.writeFileSync(path_1.default.join(this.runDirectory, 'code.js'), (0, generate_script_1.default)('', String(this.executionHistory.userId)));
+                console.log('Created empty script due to download error');
+                throw error;
+            }
+        });
+    }
+    downloadFilesFromEnvVariables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (((_a = this === null || this === void 0 ? void 0 : this.runFrom) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "turbotic-external-api") {
+                    console.log('Downloading files from environment variables for Turbotic External API');
+                    const fileEnvVars = this.envVariables.filter((envVar) => {
+                        // Handle single file (object)
+                        if (envVar.valueFile && typeof envVar.valueFile === 'object' && !Array.isArray(envVar.valueFile)) {
+                            return envVar.valueFile.url && envVar.valueFile.fileName;
+                        }
+                        // Handle multiple files (array)
+                        if (envVar.valueFile && Array.isArray(envVar.valueFile)) {
+                            return envVar.valueFile.length > 0 && envVar.valueFile.every(file => file.url && file.fileName);
+                        }
+                        return false;
+                    });
+                    if (fileEnvVars.length === 0) {
+                        console.log('No file-related environment variables found');
+                        return;
+                    }
+                    console.log(`Found ${fileEnvVars.length} file-related environment variables`);
+                    // Call the API endpoint to download files
+                    const apiUrl = (yield this.getAgentEndpoint()) + '/api/download-from-env';
+                    const response = yield fetch(apiUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Script-Runner': 'true',
+                            'User-Agent': 'TurboticAI-ScriptRunner/1.0'
+                        },
+                        body: JSON.stringify({ envVariables: fileEnvVars, automationId: this.automationId })
+                    });
+                    const result = yield this.safeJsonParse(response);
+                    if (result.error) {
+                        throw new Error(result.error);
+                    }
+                    console.log(`Files fetched successfully: ${result.totalFiles} files`);
+                    // Group files by environment variable name
+                    const filesByEnvVar = {};
+                    for (const downloadedFile of result.downloadedFiles) {
+                        if (!filesByEnvVar[downloadedFile.envVarName]) {
+                            filesByEnvVar[downloadedFile.envVarName] = [];
+                        }
+                        filesByEnvVar[downloadedFile.envVarName].push(downloadedFile);
+                    }
+                    // Process each environment variable
+                    for (const [envVarName, files] of Object.entries(filesByEnvVar)) {
+                        try {
+                            const envVar = this.envVariables.find((env) => env.name === envVarName);
+                            if (!envVar)
+                                continue;
+                            if (files.length === 1) {
+                                const downloadedFile = files[0];
+                                const fileName = downloadedFile.fileName || `${Date.now()}_${envVarName}`;
+                                const localFilePath = path_1.default.join(this.runDirectory, fileName);
+                                const buffer = Buffer.from(downloadedFile.contentBase64, 'base64');
+                                fs_extra_1.default.writeFileSync(localFilePath, buffer);
+                                // Check if it's a ZIP file and extract it
+                                if (fileName.toLowerCase().endsWith('.zip')) {
+                                    const extractedFiles = yield this.extractZipFile(localFilePath, envVarName);
+                                    if (extractedFiles.length > 0) {
+                                        envVar.value = JSON.stringify(extractedFiles);
+                                        // store only the file names in the extractedFiles array
+                                        envVar.extractedFiles = extractedFiles.map((file) => file.fileName);
+                                        console.log(`Extracted ${extractedFiles.length} files from ZIP ${envVarName}`);
+                                    }
+                                    else {
+                                        envVar.value = localFilePath;
+                                        console.log(`ZIP extraction failed, using ZIP file ${envVarName}`);
+                                    }
+                                }
+                                else {
+                                    envVar.value = localFilePath;
+                                    console.log(`Wrote single file ${envVarName} to ${localFilePath}`);
+                                }
+                            }
+                            else {
+                                // Multiple files - set as array of paths
+                                const filePaths = [];
+                                for (const downloadedFile of files) {
+                                    const fileName = downloadedFile.fileName || `${Date.now()}_${envVarName}_${files.indexOf(downloadedFile)}`;
+                                    const localFilePath = path_1.default.join(this.runDirectory, fileName);
+                                    const buffer = Buffer.from(downloadedFile.contentBase64, 'base64');
+                                    fs_extra_1.default.writeFileSync(localFilePath, buffer);
+                                    // Check if it's a ZIP file and extract it
+                                    if (fileName.toLowerCase().endsWith('.zip')) {
+                                        const extractedFiles = yield this.extractZipFile(localFilePath, `${envVarName}_${files.indexOf(downloadedFile)}`);
+                                        filePaths.push(...extractedFiles);
+                                        console.log(`Extracted ${extractedFiles.length} files from ZIP ${fileName}`);
+                                    }
+                                    else {
+                                        filePaths.push({
+                                            filePath: localFilePath,
+                                            fileName: fileName
+                                        });
+                                    }
+                                }
+                                envVar.value = JSON.stringify(filePaths);
+                                console.log(`Wrote ${filePaths.length} files for ${envVarName}`);
+                            }
+                        }
+                        catch (e) {
+                            console.error(`Failed to write files for environment variable ${envVarName}:`, e);
+                        }
+                    }
+                    console.log('Files downloaded from environment variables & local file path updated in env variables');
+                    return;
+                }
+                else {
+                    console.log('Downloading files from environment variables for the Turbotic AI platform');
+                    let environmentStrategy = this.runtimeEnvironment;
+                    console.log(`Using environment strategy: ${environmentStrategy}`);
+                    // Process environment variables to extract the correct environment's valueFile
+                    const processedEnvVars = this.envVariables.map((envVar) => {
+                        if (!envVar.valueFile) {
+                            return envVar;
+                        }
+                        // Create a copy to avoid mutating the original
+                        const processedEnvVar = Object.assign({}, envVar);
+                        // Handle multi-environment structure for valueFile
+                        if (typeof envVar.valueFile === 'object' && !Array.isArray(envVar.valueFile)) {
+                            // Check if it's the new multi-environment structure (has dev/test/production keys)
+                            if (envVar.valueFile.dev !== undefined || envVar.valueFile.test !== undefined || envVar.valueFile.production !== undefined) {
+                                // Extract the appropriate environment's file(s)
+                                // Each environment can contain either a single file object or an array of file objects
+                                let extractedValue = null;
+                                if (environmentStrategy === 'dev' && envVar.valueFile.dev !== undefined) {
+                                    extractedValue = envVar.valueFile.dev;
+                                }
+                                else if (environmentStrategy === 'test' && envVar.valueFile.test !== undefined) {
+                                    extractedValue = envVar.valueFile.test;
+                                }
+                                else if (environmentStrategy === 'production' && envVar.valueFile.production !== undefined) {
+                                    extractedValue = envVar.valueFile.production;
+                                }
+                                else {
+                                    // Fallback to first available environment
+                                    extractedValue = envVar.valueFile.dev !== undefined ? envVar.valueFile.dev :
+                                        (envVar.valueFile.test !== undefined ? envVar.valueFile.test :
+                                            envVar.valueFile.production);
+                                }
+                                // Assign the extracted value back to valueFile
+                                processedEnvVar.valueFile = extractedValue;
+                            }
+                            // If it's the old structure (single file object), keep it as is
+                        }
+                        // If it's an array, check if it contains multi-environment structures
+                        else if (Array.isArray(envVar.valueFile)) {
+                            // Process each file item to handle multi-environment structures
+                            const processedFiles = [];
+                            for (const file of envVar.valueFile) {
+                                // Check if this file item has multi-environment structure
+                                if (file && typeof file === 'object' && !Array.isArray(file)) {
+                                    if (file.dev !== undefined || file.test !== undefined || file.production !== undefined) {
+                                        // Extract the appropriate environment's file
+                                        let extractedFile = null;
+                                        if (environmentStrategy === 'dev' && file.dev !== undefined) {
+                                            extractedFile = file.dev;
+                                        }
+                                        else if (environmentStrategy === 'test' && file.test !== undefined) {
+                                            extractedFile = file.test;
+                                        }
+                                        else if (environmentStrategy === 'production' && file.production !== undefined) {
+                                            extractedFile = file.production;
+                                        }
+                                        else {
+                                            // Fallback to first available environment
+                                            extractedFile = file.dev !== undefined ? file.dev :
+                                                (file.test !== undefined ? file.test : file.production);
+                                        }
+                                        processedFiles.push(extractedFile);
+                                    }
+                                    else {
+                                        // Not a multi-environment structure, keep as is
+                                        processedFiles.push(file);
+                                    }
+                                }
+                                else {
+                                    // Not an object, keep as is
+                                    processedFiles.push(file);
+                                }
+                            }
+                            processedEnvVar.valueFile = processedFiles;
+                        }
+                        return processedEnvVar;
+                    });
+                    // Check if environment variables contain file references
+                    const fileEnvVars = processedEnvVars.filter((envVar) => {
+                        // Handle single file (object)
+                        if (envVar.valueFile && typeof envVar.valueFile === 'object' && !Array.isArray(envVar.valueFile)) {
+                            return envVar.valueFile.url && envVar.valueFile.fileName;
+                        }
+                        // Handle multiple files (array)
+                        if (envVar.valueFile && Array.isArray(envVar.valueFile)) {
+                            return envVar.valueFile.length > 0 && envVar.valueFile.every(file => file.url && file.fileName);
+                        }
+                        return false;
+                    });
+                    if (fileEnvVars.length === 0) {
+                        console.log('No file-related environment variables found');
+                        return;
+                    }
+                    console.log(`Found ${fileEnvVars.length} file-related environment variables`);
+                    // Call the API endpoint to download files
+                    const apiUrl = (yield this.getAgentEndpoint()) + '/api/download-from-env';
+                    const response = yield fetch(apiUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Script-Runner': 'true',
+                            'User-Agent': 'TurboticAI-ScriptRunner/1.0'
+                        },
+                        body: JSON.stringify({ envVariables: fileEnvVars, automationId: this.automationId })
+                    });
+                    const result = yield this.safeJsonParse(response);
+                    if (result.error) {
+                        throw new Error(result.error);
+                    }
+                    console.log(`Files fetched successfully: ${result.totalFiles} files`);
+                    // Group files by environment variable name
+                    const filesByEnvVar = {};
+                    for (const downloadedFile of result.downloadedFiles) {
+                        if (!filesByEnvVar[downloadedFile.envVarName]) {
+                            filesByEnvVar[downloadedFile.envVarName] = [];
+                        }
+                        filesByEnvVar[downloadedFile.envVarName].push(downloadedFile);
+                    }
+                    // Update this.envVariables with processed values for consistency
+                    this.envVariables = processedEnvVars;
+                    // Process each environment variable
+                    for (const [envVarName, files] of Object.entries(filesByEnvVar)) {
+                        try {
+                            const envVar = processedEnvVars.find((env) => env.name === envVarName);
+                            if (!envVar)
+                                continue;
+                            if (files.length === 1) {
+                                const downloadedFile = files[0];
+                                const fileName = downloadedFile.fileName || `${Date.now()}_${envVarName}`;
+                                const localFilePath = path_1.default.join(this.runDirectory, fileName);
+                                const buffer = Buffer.from(downloadedFile.contentBase64, 'base64');
+                                fs_extra_1.default.writeFileSync(localFilePath, buffer);
+                                // Check if it's a ZIP file and extract it
+                                if (fileName.toLowerCase().endsWith('.zip')) {
+                                    const extractedFiles = yield this.extractZipFile(localFilePath, envVarName);
+                                    if (extractedFiles.length > 0) {
+                                        envVar.value = JSON.stringify(extractedFiles);
+                                        // store only the file names in the extractedFiles array
+                                        envVar.extractedFiles = extractedFiles.map((file) => file.fileName);
+                                        console.log(`Extracted ${extractedFiles.length} files from ZIP ${envVarName}`);
+                                    }
+                                    else {
+                                        envVar.value = localFilePath;
+                                        console.log(`ZIP extraction failed, using ZIP file ${envVarName}`);
+                                    }
+                                }
+                                else {
+                                    envVar.value = localFilePath;
+                                    console.log(`Wrote single file ${envVarName} to ${localFilePath}`);
+                                }
+                            }
+                            else {
+                                // Multiple files - set as array of paths
+                                const filePaths = [];
+                                for (const downloadedFile of files) {
+                                    const fileName = downloadedFile.fileName || `${Date.now()}_${envVarName}_${files.indexOf(downloadedFile)}`;
+                                    const localFilePath = path_1.default.join(this.runDirectory, fileName);
+                                    const buffer = Buffer.from(downloadedFile.contentBase64, 'base64');
+                                    fs_extra_1.default.writeFileSync(localFilePath, buffer);
+                                    // Check if it's a ZIP file and extract it
+                                    if (fileName.toLowerCase().endsWith('.zip')) {
+                                        const extractedFiles = yield this.extractZipFile(localFilePath, `${envVarName}_${files.indexOf(downloadedFile)}`);
+                                        filePaths.push(...extractedFiles);
+                                        console.log(`Extracted ${extractedFiles.length} files from ZIP ${fileName}`);
+                                    }
+                                    else {
+                                        filePaths.push({
+                                            filePath: localFilePath,
+                                            fileName: fileName
+                                        });
+                                    }
+                                }
+                                // Store filepaths as an array in envVar.value
+                                const filePathsArray = [];
+                                for (const filePath of filePaths) {
+                                    filePathsArray.push(filePath.filePath);
+                                }
+                                envVar.value = filePathsArray;
+                                console.log(`Wrote ${filePaths.length} files for ${envVarName}`);
+                            }
+                        }
+                        catch (e) {
+                            console.error(`Failed to write files for environment variable ${envVarName}:`, e);
+                        }
+                    }
+                    console.log('Files downloaded from environment variables & local file path updated in env variables');
+                    return;
+                }
+            }
+            catch (error) {
+                console.error('Error downloading files from environment variables:', error);
+            }
+        });
+    }
+    extractZipFile(zipFilePath, envVarName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const zip = new adm_zip_1.default(zipFilePath);
+                const extractedFiles = [];
+                // Extract all files directly to run directory
+                zip.extractAllTo(this.runDirectory, true);
+                // Get all extracted files from run directory
+                const getAllFiles = (dir) => {
+                    let files = [];
+                    const items = fs_extra_1.default.readdirSync(dir);
+                    for (const item of items) {
+                        const fullPath = path_1.default.join(dir, item);
+                        const stat = fs_extra_1.default.statSync(fullPath);
+                        if (stat.isDirectory()) {
+                            files = files.concat(getAllFiles(fullPath));
+                        }
+                        else {
+                            files.push(fullPath);
+                        }
+                    }
+                    return files;
+                };
+                const extractedFilePaths = getAllFiles(this.runDirectory);
+                // Filter to only include files that were extracted from this ZIP (not existing files)
+                const zipFileName = path_1.default.basename(zipFilePath);
+                const zipBaseName = path_1.default.parse(zipFileName).name;
+                // Convert to our format - only include files that are likely from this ZIP
+                for (const filePath of extractedFilePaths) {
+                    const fileName = path_1.default.basename(filePath);
+                    // Skip the ZIP file itself and code.js
+                    if (fileName !== zipFileName && fileName !== 'code.js') {
+                        extractedFiles.push({
+                            filePath: filePath,
+                            fileName: fileName
+                        });
+                    }
+                }
+                // Clean up the ZIP file
+                fs_extra_1.default.unlinkSync(zipFilePath);
+                console.log(`Extracted ${extractedFiles.length} files from ${path_1.default.basename(zipFilePath)} to run directory`);
+                return extractedFiles;
+            }
+            catch (error) {
+                console.error(`Error extracting ZIP file ${zipFilePath}:`, error);
+                return [];
+            }
+        });
+    }
+    pushLogs(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (String(data).startsWith('Checking dependencies...')) {
+                this.__logPushPaused = false;
+            }
+            if (this.__logPushPaused === true) {
+                return;
+            }
+            if (String(data).startsWith('Run complete with exit code')) {
+                this.__logPushPaused = true;
+            }
+            clearTimeout(this.__logPushTimer);
+            this.__logBuffer.push(data);
+            this.__logPushTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                const logToPush = [...this.__logBuffer];
+                this.__logBuffer = [];
+                try {
+                    yield fetch(`${yield this.getAgentEndpoint()}/api/run/logs`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            "executionId": process.env.EXECUTION_ID,
+                            "logs": logToPush,
+                            "executionHistoryId": this.executionHistory._id
+                        })
+                    });
+                    console.log('Logs pushed', logToPush);
+                }
+                catch (e) {
+                    console.log(data);
+                }
+                finally {
+                    if (this.__killAfterLogPush === true) {
+                        this.__ack();
+                        yield new Promise((resolve) => setTimeout(resolve, 3000));
+                        if (process.env.USE_SCRIPT_RUNNER_AGENT === 'true') {
+                            console.log('Shutting down script runner agent...');
+                            yield fetch(`${process.env.SCRIPT_RUNNER_AGENT_ENDPOINT}/api/shutdown`, {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                },
+                            });
+                        }
+                        process.exit(0);
+                    }
+                }
+            }), 1000);
+        });
+    }
+    fetchLatestExecutionHistory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${yield this.getAgentEndpoint()}/api/run/execution-history`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    executionId: process.env.EXECUTION_ID
+                })
+            });
+            const executionHistory = yield this.safeJsonParse(response);
+            this.executionHistory = executionHistory;
+            return executionHistory;
+        });
+    }
+    refreshExecutionHistory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.executionHistory) {
+                throw new Error('Execution history not found');
+            }
+            const response = yield fetch(`${yield this.getAgentEndpoint()}/api/run/execution-history`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    historyId: this.executionHistory._id
+                })
+            });
+            const executionHistory = yield this.safeJsonParse(response);
+            this.executionHistory = executionHistory;
+            return executionHistory;
+        });
+    }
+    updateExecutionHistory(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.executionHistory || !this.executionHistory._id) {
+                    console.error(`[UpdateExecutionHistory] No execution history or ID found!`, this.executionHistory);
+                    throw new Error('No execution history ID available');
+                }
+                const response = yield fetch(`${yield this.getAgentEndpoint()}/api/run/execution-history`, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(Object.assign(Object.assign({}, payload), { executionHistoryId: String(this.executionHistory._id) }))
+                });
+                this.executionHistory = Object.assign(Object.assign({}, this.executionHistory), payload);
+                const executionHistory = yield this.safeJsonParse(response);
+                return executionHistory;
+            }
+            catch (error) {
+                console.error(`[UpdateExecutionHistory] Error updating execution history:`, error);
+                throw error;
+            }
+        });
+    }
+    processBufferedOutput(buffer, isStdout = true) {
+        const lines = buffer.split('\n');
+        // Keep the last partial line in the buffer
+        const remainingBuffer = lines.pop() || '';
+        // Push complete lines to logs (including empty lines to preserve formatting)
+        for (const line of lines) {
+            console.log(isStdout ? 'stdout' : 'stderr', line);
+            this.pushLogs(line);
+        }
+        return remainingBuffer;
+    }
+    runCode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get agent endpoint before creating the Promise
+            const agentEndpoint = yield this.getAgentEndpoint();
+            return new Promise((resolve) => {
+                var _a, _b, _c, _d, _e, _f, _g;
+                let resume = false;
+                let runTokenId = undefined;
+                let runFromStepId = undefined;
+                let runOne = false;
+                let temporaryRunTokenId = undefined;
+                resume = ((_a = this.__queuePayload) === null || _a === void 0 ? void 0 : _a.resume) === true;
+                runFromStepId = (_b = this.__queuePayload) === null || _b === void 0 ? void 0 : _b.runFromStepId;
+                runOne = ((_c = this.__queuePayload) === null || _c === void 0 ? void 0 : _c.runOne) === true;
+                runTokenId = (_d = this.__queuePayload) === null || _d === void 0 ? void 0 : _d.runTokenId;
+                temporaryRunTokenId = (_e = this.__queuePayload) === null || _e === void 0 ? void 0 : _e.temporaryRunTokenId;
+                if (!runTokenId) {
+                    resume = false;
+                }
+                const scriptFramePath = path_1.default.join(__dirname, '..', 'script-frame', 'build', 'index.js');
+                const cmd = this.automationVersion === "3" ? `${scriptFramePath} -a ${resume === true ? 'resume' : 'run'} ${resume === true ? '-t ' + runTokenId : ''} -e ${process.env.EXECUTION_ID} -u ${agentEndpoint} ${runFromStepId ? '-s ' + runFromStepId : ''} ${runOne ? '-o' : ''} ${temporaryRunTokenId ? '--tempTokenId ' + temporaryRunTokenId : ''}` : `node code.js`;
+                // Reset buffers for new run
+                this.__stdoutBuffer = '';
+                this.__stderrBuffer = '';
+                const customEnv = this.envVariables.reduce((acc, curr) => {
+                    // If value is an array, stringify it so it can be parsed back in the automation script
+                    acc[curr.name] = Array.isArray(curr.value) ? JSON.stringify(curr.value) : curr.value;
+                    return acc;
+                }, {});
+                const triggerAutokill = () => {
+                    const minutes = 2;
+                    clearTimeout(this._autokillTimeout);
+                    this._autokillTimeout = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        try {
+                            console.log('Sending exit command to process');
+                            (_a = this._runProcess.stdin) === null || _a === void 0 ? void 0 : _a.write('exit\n');
+                            console.log('Sent exit command to process');
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                        yield new Promise((resolve) => setTimeout(resolve, 3000));
+                        console.log('Autokilling process');
+                        try {
+                            this._runProcess.kill('SIGKILL');
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                        const message = `Process autokilled because script was running for ${minutes} minute${minutes > 1 ? 's' : ''} without any new logs. Indicating that it is waiting for input or connection to close or hang.`;
+                        this.pushLogs(message);
+                        yield this.updateExecutionHistory({
+                            status: 'errored',
+                            endedAt: new Date(),
+                            error: message
+                        });
+                        this.__killAfterLogPush = true;
+                        this.pushLogs(`Run complete with exit code 137`);
+                    }), 1000 * 60 * minutes);
+                };
+                this._runProcess = (0, child_process_1.exec)(cmd, {
+                    cwd: this.runDirectory,
+                    env: Object.assign(Object.assign(Object.assign({}, process.env), { NODE_ENV: 'production' }), customEnv)
+                });
+                // Listen to stdout data
+                (_f = this._runProcess.stdout) === null || _f === void 0 ? void 0 : _f.on('data', (data) => {
+                    this.__stdoutBuffer += data.toString();
+                    this.__stdoutBuffer = this.processBufferedOutput(this.__stdoutBuffer, true);
+                    triggerAutokill();
+                });
+                // Listen to stderr data
+                (_g = this._runProcess.stderr) === null || _g === void 0 ? void 0 : _g.on('data', (data) => {
+                    this.__stderrBuffer += data.toString();
+                    this.__stderrBuffer = this.processBufferedOutput(this.__stderrBuffer, false);
+                    triggerAutokill();
+                });
+                // Flag to prevent multiple resolutions
+                let resolved = false;
+                const handleProcessCompletion = (code, signal, eventType) => {
+                    if (resolved) {
+                        console.log(`Process completion already handled, ignoring ${eventType} event`);
+                        return;
+                    }
+                    resolved = true;
+                    console.log(`Process ${eventType} with exit code: ${code}, signal: ${signal}`);
+                    clearTimeout(this._autokillTimeout);
+                    // Process any remaining buffered output
+                    if (this.__stdoutBuffer.trim()) {
+                        console.log('stdout', this.__stdoutBuffer);
+                        this.pushLogs(this.__stdoutBuffer);
+                        this.__stdoutBuffer = '';
+                    }
+                    if (this.__stderrBuffer.trim()) {
+                        console.log('stderr', this.__stderrBuffer);
+                        this.pushLogs(this.__stderrBuffer);
+                        this.__stderrBuffer = '';
+                    }
+                    // this.socket.emit('execution_complete', { exitCode: code });
+                    const exitCode = code === null || isNaN(code) ? (signal === 'SIGKILL' ? 137 : 0) : code;
+                    this.pushLogs(`Run complete with exit code ${exitCode}`);
+                    resolve(exitCode);
+                };
+                // Listen for process exit (fires when process exits, more reliable in containers)
+                // This fires BEFORE close and doesn't wait for stdio streams to close
+                this._runProcess.on('exit', (code, signal) => {
+                    handleProcessCompletion(code, signal, 'exit');
+                });
+                // Listen for process close (fires after stdio streams close, may not fire in K8s)
+                // Keep as fallback but exit event should handle it first
+                this._runProcess.on('close', (code, signal) => {
+                    handleProcessCompletion(code, signal, 'close');
+                });
+                // Listen for process errors (process failed to start or crashed)
+                this._runProcess.on('error', (error) => {
+                    console.error('Process error:', error);
+                    if (!resolved) {
+                        handleProcessCompletion(1, null, 'error');
+                        this.pushLogs(`Process error: ${error.message}`);
+                    }
+                });
+            });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._installProcess) {
+                try {
+                    this._installProcess.kill('SIGKILL');
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this._runProcess) {
+                try {
+                    this._runProcess.kill('SIGKILL');
+                    clearTimeout(this._autokillTimeout);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            this.running = false;
+            const message = 'Run stopped by user';
+            yield this.updateExecutionHistory({
+                status: 'stopped',
+                endedAt: new Date(),
+                error: message
+            });
+            this.__killAfterLogPush = true;
+            this.pushLogs(`Run complete with exit code 137`);
+            clearInterval(this.cancelCheckInterval);
+        });
+    }
+    shouldContinue() {
+        var _a;
+        if (((_a = this.executionHistory) === null || _a === void 0 ? void 0 : _a.cancelRequested) === true) {
+            return false;
+        }
+        return true;
+    }
+    __run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let startTime, endTime;
+            try {
+                clearInterval(this.cancelCheckInterval);
+                try {
+                    yield this.fetchLatestExecutionHistory();
+                }
+                catch (e) {
+                    this.__ack();
+                    console.log('Shutting down script runner agent because exectution history cannot be fetched...');
+                    yield fetch(`${process.env.SCRIPT_RUNNER_AGENT_ENDPOINT}/api/shutdown`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                    process.exit(0);
+                }
+                this.cancelCheckInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    console.log('Checking for cancellation');
+                    try {
+                        yield this.refreshExecutionHistory();
+                        if (((_a = this.executionHistory) === null || _a === void 0 ? void 0 : _a.cancelRequested) === true) {
+                            clearInterval(this.cancelCheckInterval);
+                            this.pushLogs('Cancellation requested, stopping run');
+                            yield this.stop();
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }), 5 * 1000);
+                yield this.updateExecutionHistory({
+                    status: 'running',
+                    startedAt: new Date()
+                });
+                startTime = (0, performance_now_1.default)();
+                this.running = true;
+                console.log('Starting run');
+                yield this.pushLogs('clear');
+                if (this.shouldContinue()) {
+                    yield this.downloadCode();
+                    //download files from env variables
+                    try {
+                        yield this.downloadFilesFromEnvVariables();
+                    }
+                    catch (error) {
+                        console.error('Error downloading files from env variables:', error);
+                    }
+                }
+                if (this.shouldContinue()) {
+                    yield this.pushLogs('Checking dependencies...');
+                    yield this.installDependencies();
+                    yield new Promise((resolve) => setTimeout(resolve, 800));
+                }
+                if (this.shouldContinue()) {
+                    yield this.pushLogs('clear');
+                    yield this.pushLogs('Running latest changes...');
+                    const exitCode = yield this.runCode();
+                    endTime = (0, performance_now_1.default)();
+                    if (exitCode === 0 || exitCode === 2) {
+                        yield this.updateExecutionHistory({
+                            status: 'completed',
+                            endedAt: new Date(),
+                            durationInMs: (endTime - startTime).toFixed(3),
+                        });
+                        //upload artifacts to blob storage
+                        try {
+                            yield this.uploadArtifactsToBlobStorage();
+                        }
+                        catch (error) {
+                            console.error('Error uploading artifacts to blob storage:', error);
+                        }
+                        // Store automation components in vector search after successful execution
+                        try {
+                            const isVectorSearchToolInvoked = process.env.ENABLE_VECTOR_SEARCH === 'true' || false;
+                            if (isVectorSearchToolInvoked) {
+                                yield this.storeAutomationComponents();
+                            }
+                        }
+                        catch (error) {
+                            console.error('Error storing automation components:', error);
+                        }
+                    }
+                    else {
+                        yield this.updateExecutionHistory({
+                            status: 'errored',
+                            endedAt: new Date(),
+                            error: `Run failed with exit code ${exitCode}`,
+                            durationInMs: (endTime - startTime).toFixed(3)
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.log('Caught error, handling it...');
+                endTime = (0, performance_now_1.default)();
+                try {
+                    yield this.updateExecutionHistory({
+                        status: 'errored',
+                        endedAt: new Date(),
+                        error: error,
+                        durationInMs: (endTime - startTime).toFixed(3)
+                    });
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                this.running = false;
+                console.error(error);
+                this.pushLogs(`Run complete with exit code 500`);
+            }
+            finally {
+                this.running = false;
+                clearInterval(this.cancelCheckInterval);
+            }
+        });
+    }
+    run(_ack, _queuePayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.__queuePayload = _queuePayload;
+            this.__ack = _ack;
+            return this.__run();
+        });
+    }
+    storeAutomationComponents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                // Read the executed script
+                const scriptPath = path_1.default.join(this.runDirectory, 'code.js');
+                if (!fs_extra_1.default.existsSync(scriptPath)) {
+                    console.log('No script file found to analyze');
+                    return;
+                }
+                const script = fs_extra_1.default.readFileSync(scriptPath, 'utf8');
+                // Call the vector search service to store components
+                const vectorStoreResponse = yield fetch(`${yield this.getAgentEndpoint()}/api/vector-search/store-components`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Script-Runner': 'true',
+                        'User-Agent': 'TurboticAI-ScriptRunner/1.0'
+                    },
+                    body: JSON.stringify({
+                        automationId: this.automationId,
+                        script: script,
+                        workspaceId: ((_a = this.executionHistory) === null || _a === void 0 ? void 0 : _a.workspaceId) || ''
+                    })
+                });
+            }
+            catch (error) {
+                console.error('Error in storeAutomationComponents:', error);
+            }
+        });
+    }
+    uploadArtifactsToBlobStorage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const envVar of this.envVariables) {
+                    // Handle single file (object)
+                    if (envVar.valueFile && typeof envVar.valueFile === 'object' && !Array.isArray(envVar.valueFile)) {
+                        if (envVar.extractedFiles && envVar.extractedFiles.length > 0 && envVar.valueFile.fileName.toLowerCase().endsWith('.zip')) {
+                            this.executionFiles.push(...envVar.extractedFiles);
+                        }
+                        else if (envVar.valueFile.url && envVar.valueFile.fileName) {
+                            this.executionFiles.push(envVar.valueFile.fileName);
+                        }
+                    }
+                    // Handle multiple files (array)
+                    else if (envVar.valueFile && Array.isArray(envVar.valueFile)) {
+                        for (const file of envVar.valueFile) {
+                            if (file.url && file.fileName) {
+                                this.executionFiles.push(file.fileName);
+                            }
+                        }
+                    }
+                }
+                const currentFiles = fs_extra_1.default.readdirSync(this.runDirectory);
+                let outputFiles = currentFiles.filter((file) => !this.executionFiles.includes(file));
+                if (outputFiles.length === 0) {
+                    console.log('No artifacts found to upload');
+                    return;
+                }
+                console.log(`Found ${outputFiles.length} artifacts to upload`);
+                // Create a zip of all PDFs if there are 3 or more PDFs (convenience feature)
+                const pdfFiles = outputFiles.filter(f => f.toLowerCase().endsWith('.pdf'));
+                if (pdfFiles.length >= 3) {
+                    try {
+                        const zip = new adm_zip_1.default();
+                        for (const pdfFile of pdfFiles) {
+                            const pdfPath = path_1.default.join(this.runDirectory, pdfFile);
+                            zip.addLocalFile(pdfPath, '', pdfFile);
+                        }
+                        const zipFileName = 'all_pdfs.zip';
+                        const zipPath = path_1.default.join(this.runDirectory, zipFileName);
+                        zip.writeZip(zipPath);
+                        console.log(`Created zip file with ${pdfFiles.length} PDFs: ${zipFileName}`);
+                        // Add zip to output files if not already there
+                        if (!outputFiles.includes(zipFileName)) {
+                            outputFiles.push(zipFileName);
+                        }
+                    }
+                    catch (zipError) {
+                        console.error('Error creating PDF zip file:', zipError);
+                    }
+                }
+                // Limit to first 50 files (increased from 10 to handle more artifacts)
+                const MAX_ARTIFACTS = 50;
+                if (outputFiles.length > MAX_ARTIFACTS) {
+                    outputFiles = outputFiles.slice(0, MAX_ARTIFACTS);
+                    console.log(`Processing first ${MAX_ARTIFACTS} files due to length limit`);
+                }
+                // Prepare artifacts data for API
+                const artifacts = [];
+                for (const fileName of outputFiles) {
+                    try {
+                        const filePath = path_1.default.join(this.runDirectory, fileName);
+                        const stats = fs_extra_1.default.statSync(filePath);
+                        // Skip directories
+                        if (stats.isDirectory()) {
+                            continue;
+                        }
+                        const fileContent = fs_extra_1.default.readFileSync(filePath);
+                        const contentBase64 = fileContent.toString('base64');
+                        const mimeType = this.getMimeTypeFromFileName(fileName);
+                        artifacts.push({
+                            fileName,
+                            contentBase64,
+                            size: stats.size,
+                            mimeType
+                        });
+                    }
+                    catch (error) {
+                        console.error(`Error preparing artifact ${fileName}:`, error);
+                    }
+                }
+                if (artifacts.length === 0) {
+                    console.log('No valid artifacts to upload');
+                    return;
+                }
+                // Call the API endpoint to upload artifacts
+                const apiUrl = (yield this.getAgentEndpoint()) + '/api/upload-artifacts';
+                const response = yield fetch(apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Script-Runner': 'true',
+                        'User-Agent': 'TurboticAI-ScriptRunner/1.0'
+                    },
+                    body: JSON.stringify({
+                        artifacts,
+                        automationId: this.automationId,
+                        userId: this.executionHistory.userId
+                    })
+                });
+                if (!response.ok) {
+                    throw new Error(`API call failed: ${response.statusText}`);
+                }
+                const result = yield response.json();
+                if (result.error) {
+                    throw new Error(result.error);
+                }
+                console.log(`Artifacts uploaded successfully: ${result.totalFiles} files`);
+                // Process uploaded files and update execution history
+                for (const uploadedFile of result.uploadedFiles) {
+                    try {
+                        // Update execution history with file ID
+                        const updatePayload = {
+                            outputFiles: this.executionHistory.outputFiles || []
+                        };
+                        if (!updatePayload.outputFiles.some((f) => f.fileId === uploadedFile.fileId)) {
+                            updatePayload.outputFiles.push({
+                                fileId: uploadedFile.fileId,
+                                fileName: uploadedFile.fileName
+                            });
+                        }
+                        yield this.updateExecutionHistory(updatePayload);
+                        console.log(`Execution history updated with file ID: ${uploadedFile.fileId}`);
+                        // Remove local file after successful upload
+                        const filePath = path_1.default.join(this.runDirectory, uploadedFile.fileName);
+                        if (fs_extra_1.default.existsSync(filePath)) {
+                            fs_extra_1.default.unlinkSync(filePath);
+                            console.log(`Local artifact removed: ${uploadedFile.fileName}`);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error processing uploaded file ${uploadedFile.fileName}:`, error);
+                    }
+                }
+                console.log('Artifact upload process completed');
+            }
+            catch (error) {
+                console.error('Error in uploadArtifactsToBlobStorage:', error);
+            }
+        });
+    }
+    getMimeTypeFromFileName(fileName) {
+        const extension = path_1.default.extname(fileName).toLowerCase();
+        const mimeTypes = {
+            '.txt': 'text/plain',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.csv': 'text/csv',
+            '.pdf': 'application/pdf',
+            '.zip': 'application/zip',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.xls': 'application/vnd.ms-excel',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.doc': 'application/msword',
+            '.html': 'text/html',
+            '.css': 'text/css',
+            '.js': 'application/javascript',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.log': 'text/plain',
+            '.md': 'text/markdown'
+        };
+        return mimeTypes[extension] || 'application/octet-stream';
+    }
+}
+exports.Runner = Runner;