ai-workflow-utils
Version:
A comprehensive automation platform that streamlines software development workflows by integrating AI-powered content generation with popular development tools like Jira, Bitbucket, and email systems. Includes startup service management for automatic syst
1,385 lines (1,293 loc) • 722 kB
JavaScript
import * as __WEBPACK_EXTERNAL_MODULE__langchain_core_messages_540ae0dc__ from "@langchain/core/messages";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_core_output_parsers_dfb7bed6__ from "@langchain/core/output_parsers";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_core_prompts_e068055c__ from "@langchain/core/prompts";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_google_genai_7af88f70__ from "@langchain/google-genai";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_mcp_adapters_765205f9__ from "@langchain/mcp-adapters";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_ollama_6f1c0969__ from "@langchain/ollama";
import * as __WEBPACK_EXTERNAL_MODULE__langchain_openai_98226cd4__ from "@langchain/openai";
import * as __WEBPACK_EXTERNAL_MODULE_axios__ from "axios";
import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
import * as __WEBPACK_EXTERNAL_MODULE_cors__ from "cors";
import * as __WEBPACK_EXTERNAL_MODULE_dotenv__ from "dotenv";
import * as __WEBPACK_EXTERNAL_MODULE_events__ from "events";
import * as __WEBPACK_EXTERNAL_MODULE_express__ from "express";
import * as __WEBPACK_EXTERNAL_MODULE_form_data_737738cd__ from "form-data";
import * as __WEBPACK_EXTERNAL_MODULE_jsdom__ from "jsdom";
import * as __WEBPACK_EXTERNAL_MODULE_langchain_agents_e44685bf__ from "langchain/agents";
import * as __WEBPACK_EXTERNAL_MODULE_langchain_chains_324909f8__ from "langchain/chains";
import * as __WEBPACK_EXTERNAL_MODULE_langchain_hub_b7f5e919__ from "langchain/hub";
import * as __WEBPACK_EXTERNAL_MODULE_langchain_memory_be48638a__ from "langchain/memory";
import * as __WEBPACK_EXTERNAL_MODULE_langchain_output_parsers_0d83e0d7__ from "langchain/output_parsers";
import * as __WEBPACK_EXTERNAL_MODULE_lowdb__ from "lowdb";
import * as __WEBPACK_EXTERNAL_MODULE_lowdb_node_2f91f502__ from "lowdb/node";
import * as __WEBPACK_EXTERNAL_MODULE_multer__ from "multer";
import * as __WEBPACK_EXTERNAL_MODULE_socket_io_17ea7cc2__ from "socket.io";
import * as __WEBPACK_EXTERNAL_MODULE_unidiff__ from "unidiff";
import * as __WEBPACK_EXTERNAL_MODULE_uuid__ from "uuid";
import * as __WEBPACK_EXTERNAL_MODULE_winston__ from "winston";
import * as __WEBPACK_EXTERNAL_MODULE_ws__ from "ws";
import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
/******/ var __webpack_modules__ = ({
/***/ "./server/controllers/api-client-collection/api-client-collection-controller.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ $I: () => (/* binding */ exportCollection),
/* harmony export */ IX: () => (/* binding */ updateCollection),
/* harmony export */ No: () => (/* binding */ createCollection),
/* harmony export */ X_: () => (/* binding */ getCollection),
/* harmony export */ gR: () => (/* binding */ importCollection),
/* harmony export */ o4: () => (/* binding */ deleteCollection),
/* harmony export */ qw: () => (/* binding */ getCollections),
/* harmony export */ rU: () => (/* binding */ exportAllCollections)
/* harmony export */ });
/* harmony import */ var _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/services/apiClientCollectionDbService.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./server/logger.js");
/**
* Create a new collection
*/
const createCollection = async (req, res) => {
try {
const {
name,
description,
requests
} = req.body;
if (!name) {
return res.status(400).json({
success: false,
error: 'Collection name is required'
});
}
const collection = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.createCollection({
name,
description: description || '',
requests: requests || []
});
res.json({
success: true,
data: collection
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to create collection:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Get all collections
*/
const getCollections = async (req, res) => {
try {
const collections = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getCollections();
res.json({
success: true,
data: collections
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to get collections:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Get a specific collection
*/
const getCollection = async (req, res) => {
try {
const {
id
} = req.params;
const collection = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getCollection(id);
res.json({
success: true,
data: collection
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to get collection:', error);
res.status(404).json({
success: false,
error: error.message
});
}
};
/**
* Update a collection
*/
const updateCollection = async (req, res) => {
try {
const {
id
} = req.params;
const {
name,
description,
requests,
auth,
variable
} = req.body;
const collection = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.updateCollection(id, {
name,
description,
requests,
auth,
variable
});
res.json({
success: true,
data: collection
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to update collection:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Delete a collection
*/
const deleteCollection = async (req, res) => {
try {
const {
id
} = req.params;
await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.deleteCollection(id);
res.json({
success: true,
data: {
message: 'Collection deleted successfully'
}
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to delete collection:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Import a collection (Postman format)
*/
const importCollection = async (req, res) => {
try {
const {
collection
} = req.body;
if (!collection) {
return res.status(400).json({
success: false,
error: 'Collection data is required'
});
}
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.info('📥 API Client: Importing Postman collection');
const importedCollection = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.importCollection(collection);
res.json({
success: true,
data: importedCollection,
message: 'Collection imported successfully'
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('❌ API Client: Failed to import collection:', error.message);
res.status(500).json({
success: false,
error: error.message || 'Failed to import collection'
});
}
};
/**
* Export a specific collection (Postman format)
*/
const exportCollection = async (req, res) => {
try {
const {
id
} = req.params;
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.info(`📤 API Client: Exporting collection ${id} to Postman format`);
const collection = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.exportCollection(id);
res.setHeader('Content-Type', 'application/json');
res.setHeader('Content-Disposition', `attachment; filename=${collection.info.name.replace(/[^a-z0-9]/gi, '_')}.postman_collection.json`);
res.json(collection);
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('❌ API Client: Failed to export collection:', error.message);
res.status(500).json({
success: false,
error: error.message || 'Failed to export collection'
});
}
};
/**
* Export all collections (Postman format)
*/
const exportAllCollections = async (req, res) => {
try {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.info('📤 API Client: Exporting all collections to Postman format');
const data = await _services_apiClientCollectionDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.exportAllCollections();
res.setHeader('Content-Type', 'application/json');
res.setHeader('Content-Disposition', 'attachment; filename=ai-workflow-utils-collections.json');
res.json({
success: true,
data
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('❌ API Client: Failed to export all collections:', error.message);
res.status(500).json({
success: false,
error: error.message || 'Failed to export collections'
});
}
};
/***/ }),
/***/ "./server/controllers/api-client-collection/index.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ $I: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.$I),
/* harmony export */ IX: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.IX),
/* harmony export */ No: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.No),
/* harmony export */ X_: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.X_),
/* harmony export */ gR: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.gR),
/* harmony export */ o4: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.o4),
/* harmony export */ qw: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.qw),
/* harmony export */ rU: () => (/* reexport safe */ _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__.rU)
/* harmony export */ });
/* harmony import */ var _api_client_collection_controller_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/controllers/api-client-collection/api-client-collection-controller.js");
/***/ }),
/***/ "./server/controllers/api-client-environment/api-client-environment-controller.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ DL: () => (/* binding */ getEnvironments),
/* harmony export */ MO: () => (/* binding */ createEnvironment),
/* harmony export */ Ot: () => (/* binding */ getActiveEnvironment),
/* harmony export */ QA: () => (/* binding */ setActiveEnvironment),
/* harmony export */ h8: () => (/* binding */ updateEnvironment),
/* harmony export */ ie: () => (/* binding */ exportAllEnvironments),
/* harmony export */ jA: () => (/* binding */ deleteEnvironment),
/* harmony export */ qw: () => (/* binding */ exportEnvironment),
/* harmony export */ rn: () => (/* binding */ importEnvironment),
/* harmony export */ uc: () => (/* binding */ getEnvironment)
/* harmony export */ });
/* harmony import */ var _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/services/apiClientEnvironmentDbService.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./server/logger.js");
/**
* Create a new environment
*/
const createEnvironment = async (req, res) => {
try {
const {
name,
variables
} = req.body;
if (!name) {
return res.status(400).json({
success: false,
error: 'Environment name is required'
});
}
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.createEnvironment({
name,
variables: variables || []
});
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to create environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Get all environments
*/
const getEnvironments = async (req, res) => {
try {
const environments = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getEnvironments();
res.json({
success: true,
data: environments
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to get environments:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Get a specific environment
*/
const getEnvironment = async (req, res) => {
try {
const {
id
} = req.params;
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getEnvironment(id);
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to get environment:', error);
res.status(404).json({
success: false,
error: error.message
});
}
};
/**
* Update an environment
*/
const updateEnvironment = async (req, res) => {
try {
const {
id
} = req.params;
const {
name,
variables
} = req.body;
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.updateEnvironment(id, {
name,
variables
});
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to update environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Delete an environment
*/
const deleteEnvironment = async (req, res) => {
try {
const {
id
} = req.params;
await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.deleteEnvironment(id);
res.json({
success: true,
data: {
message: 'Environment deleted successfully'
}
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to delete environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Set active environment
*/
const setActiveEnvironment = async (req, res) => {
try {
const {
id
} = req.params;
await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.setActiveEnvironment(id);
res.json({
success: true,
data: {
message: 'Active environment set successfully'
}
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to set active environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Get active environment
*/
const getActiveEnvironment = async (req, res) => {
try {
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getActiveEnvironment();
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to get active environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Import environment from API Client v2.1 format
*/
const importEnvironment = async (req, res) => {
try {
const apiClientEnvironment = req.body;
if (!apiClientEnvironment || !apiClientEnvironment.name) {
return res.status(400).json({
success: false,
error: 'Environment data with name is required'
});
}
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.importEnvironment(apiClientEnvironment);
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to import environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Export environment in API Client v2.1 format
*/
const exportEnvironment = async (req, res) => {
try {
const {
id
} = req.params;
const environment = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.exportEnvironment(id);
res.json({
success: true,
data: environment
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to export environment:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/**
* Export all environments
*/
const exportAllEnvironments = async (req, res) => {
try {
const environments = await _services_apiClientEnvironmentDbService_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.exportAllEnvironments();
res.json({
success: true,
data: environments
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.error('Failed to export all environments:', error);
res.status(500).json({
success: false,
error: error.message
});
}
};
/***/ }),
/***/ "./server/controllers/api-client-environment/index.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ EB: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.DL),
/* harmony export */ MO: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.MO),
/* harmony export */ Ot: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.Ot),
/* harmony export */ QA: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.QA),
/* harmony export */ h8: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.h8),
/* harmony export */ ie: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.ie),
/* harmony export */ jA: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.jA),
/* harmony export */ qw: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.qw),
/* harmony export */ rn: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.rn),
/* harmony export */ uc: () => (/* reexport safe */ _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__.uc)
/* harmony export */ });
/* harmony import */ var _api_client_environment_controller_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/controllers/api-client-environment/api-client-environment-controller.js");
/***/ }),
/***/ "./server/controllers/api-client/api-client-controller.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ HG: () => (/* binding */ executeScript),
/* harmony export */ OV: () => (/* binding */ convertNaturalLanguageToApi),
/* harmony export */ Vc: () => (/* binding */ executeRequest)
/* harmony export */ });
/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("axios");
/* harmony import */ var https__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("https");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./server/logger.js");
/* harmony import */ var _services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./server/services/langchain/LangChainApiClientService.js");
/* eslint-disable max-lines */
/* eslint-disable max-statements */
/* eslint-disable no-unused-vars */
// TODO: refactor this component and create a service
// Create axios instance with SSL configuration to avoid certificate errors
const axiosInstance = axios__WEBPACK_IMPORTED_MODULE_0__["default"].create({
httpsAgent: new https__WEBPACK_IMPORTED_MODULE_1__.Agent({
rejectUnauthorized: false // Ignore self-signed certificate errors
})
});
/**
* Convert natural language to API request configuration
*/
const convertNaturalLanguageToApi = async (req, res) => {
try {
const {
prompt,
streaming = false
} = req.body;
if (!prompt || typeof prompt !== 'string' || prompt.trim().length === 0) {
return res.status(400).json({
error: true,
message: 'Natural language prompt is required'
});
}
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info(`🤖 API Client: Converting natural language prompt: "${prompt.substring(0, 100)}..."`);
// Initialize the service if not already done
await _services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .h.initialize();
if (streaming) {
// Set up Server-Sent Events for streaming
res.writeHead(200, {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Headers': 'Cache-Control'
});
let streamingComplete = false;
let finalApiRequest = null;
const streamCallback = data => {
if (!streamingComplete) {
try {
res.write(`data: ${JSON.stringify(data)}\n\n`);
if (data.type === 'complete') {
streamingComplete = true;
// Parse the final response
_services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .h.parseAndEnhanceResponse(data.fullContent).then(apiRequest => {
finalApiRequest = apiRequest;
res.write(`data: ${JSON.stringify({
type: 'final',
apiRequest,
provider: data.provider
})}\n\n`);
res.write('data: [DONE]\n\n');
res.end();
}).catch(error => {
res.write(`data: ${JSON.stringify({
type: 'error',
error: error.message
})}\n\n`);
res.end();
});
}
} catch (writeError) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('Error writing streaming response:', writeError);
if (!res.headersSent) {
res.status(500).json({
error: 'Streaming error'
});
}
}
}
};
// Handle client disconnect
req.on('close', () => {
streamingComplete = true;
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('Client disconnected from natural language streaming');
});
try {
await _services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .h.convertNaturalLanguageToApiRequest(prompt, streamCallback);
} catch (error) {
if (!streamingComplete) {
res.write(`data: ${JSON.stringify({
type: 'error',
error: error.message
})}\n\n`);
res.end();
}
}
} else {
// Regular (non-streaming) response
const result = await _services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .h.convertNaturalLanguageToApiRequest(prompt);
// Validate the generated API request
const validation = _services_langchain_LangChainApiClientService_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .h.constructor.validateApiRequest(result.apiRequest);
if (!validation.isValid) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.warn('Generated API request validation failed:', validation.errors);
return res.json({
success: false,
error: 'Generated API request is invalid',
validationErrors: validation.errors,
apiRequest: result.apiRequest,
// Include for debugging
provider: result.provider
});
}
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info(`✅ API Client: Successfully converted natural language to API request using ${result.provider}`);
res.json({
success: true,
apiRequest: result.apiRequest,
provider: result.provider,
originalPrompt: result.originalPrompt,
validation
});
}
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('❌ API Client: Natural language conversion failed:', error.message);
if (res.headersSent) {
return; // Response already sent (streaming mode)
}
res.status(500).json({
error: true,
message: error.message || 'Failed to convert natural language to API request',
success: false
});
}
};
/**
* Execute script in Node.js context
*/
const executeScript = async (req, res) => {
try {
const {
script,
context = {}
} = req.body;
if (!script || typeof script !== 'string') {
return res.status(400).json({
error: true,
message: 'Script code is required'
});
}
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('🔧 API Client: Executing script');
// Create a safe execution context
const scriptContext = {
console: {
log: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('Script log:', ...args),
error: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('Script error:', ...args),
warn: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.warn('Script warn:', ...args)
},
// Provide access to passed context (environment variables, request data, etc.)
...context,
// Add utility functions
setEnvironmentVariable: (key, value) => {
if (!scriptContext.environment) scriptContext.environment = {};
scriptContext.environment[key] = value;
},
getEnvironmentVariable: key => {
return scriptContext.environment?.[key];
}
};
// Execute the script in a controlled way
try {
// Create a module-like execution context
const vm = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, "vm", 19));
const vmContext = vm.createContext({
console: scriptContext.console,
setEnvironmentVariable: scriptContext.setEnvironmentVariable,
getEnvironmentVariable: scriptContext.getEnvironmentVariable,
environment: context.environment || {},
request: context.request || {},
response: context.response || {},
// Add common utilities
JSON,
Date,
Math,
parseInt,
parseFloat,
encodeURIComponent,
decodeURIComponent
});
const result = vm.runInContext(script, vmContext, {
timeout: 5000,
// 5 second timeout
displayErrors: true
});
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('✅ API Client: Script executed successfully');
res.json({
success: true,
result,
environment: vmContext.environment || {},
logs: [] // In a real implementation, you'd capture console logs
});
} catch (scriptError) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('❌ API Client: Script execution failed:', scriptError.message);
res.json({
success: false,
error: scriptError.message,
stack: scriptError.stack
});
}
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('❌ API Client: Script execution setup failed:', error.message);
res.status(500).json({
error: true,
message: error.message || 'Failed to execute script',
success: false
});
}
};
// Helper function to execute scripts safely
const executeScriptSafely = async (script, context) => {
if (!script || !script.trim()) return {
success: true,
environment: context.environment || {}
};
try {
const vm = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, "vm", 19));
const vmContext = vm.createContext({
console: {
log: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('Script log:', ...args),
error: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('Script error:', ...args),
warn: (...args) => _logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.warn('Script warn:', ...args)
},
setEnvironmentVariable: (key, value) => {
if (!vmContext.environment) vmContext.environment = {};
vmContext.environment[key] = value;
},
getEnvironmentVariable: key => {
return vmContext.environment?.[key];
},
environment: {
...(context.environment || {})
},
request: context.request || {},
response: context.response || {},
// Add common utilities
JSON,
Date,
Math,
parseInt,
parseFloat,
encodeURIComponent,
decodeURIComponent
});
vm.runInContext(script, vmContext, {
timeout: 5000,
displayErrors: true
});
return {
success: true,
environment: vmContext.environment || context.environment || {}
};
} catch (error) {
return {
success: false,
error: error.message,
environment: context.environment || {}
};
}
};
/**
* Execute HTTP request through the API client
*/
const executeRequest = async (req, res) => {
try {
const {
method,
url,
headers = {},
params = {},
body,
bodyType,
auth,
preScript,
postScript,
environment = {}
} = req.body;
if (!url) {
return res.status(400).json({
error: true,
message: 'URL is required'
});
}
if (!method) {
return res.status(400).json({
error: true,
message: 'HTTP method is required'
});
}
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info(`🌐 API Client: Executing ${method.toUpperCase()} request to ${url}`);
// Execute pre-request script
let currentEnvironment = {
...environment
};
let preScriptResult = {
success: true
};
if (preScript && preScript.trim()) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('🔧 API Client: Executing pre-request script');
preScriptResult = await executeScriptSafely(preScript, {
environment: currentEnvironment,
request: {
method,
url,
headers,
params,
body,
bodyType,
auth
}
});
if (!preScriptResult.success) {
return res.json({
error: true,
message: `Pre-request script failed: ${preScriptResult.error}`,
preScriptError: preScriptResult.error,
status: 0,
responseTime: 0,
size: 0
});
}
currentEnvironment = preScriptResult.environment;
}
// Prepare headers with authentication
const requestHeaders = {
...headers
};
// Handle authentication
if (auth && auth.type) {
switch (auth.type) {
case 'bearer':
if (auth.token) {
requestHeaders['Authorization'] = `Bearer ${auth.token}`;
}
break;
case 'basic':
if (auth.username && auth.password) {
const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString('base64');
requestHeaders['Authorization'] = `Basic ${credentials}`;
}
break;
case 'apikey':
if (auth.apiKey && auth.apiKeyHeader) {
requestHeaders[auth.apiKeyHeader] = auth.apiKey;
}
break;
default:
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.warn(`Unknown auth type: ${auth.type}`);
}
}
// Prepare axios config
const axiosConfig = {
method: method.toLowerCase(),
url,
headers: requestHeaders,
params,
timeout: 30000,
// 30 seconds timeout
validateStatus: () => true // Don't throw for any status code
};
// Add body for methods that support it
if (['post', 'put', 'patch'].includes(method.toLowerCase()) && body) {
if (bodyType === 'json') {
try {
axiosConfig.data = typeof body === 'string' ? JSON.parse(body) : body;
axiosConfig.headers['Content-Type'] = 'application/json';
} catch (error) {
return res.status(400).json({
error: true,
message: 'Invalid JSON in request body'
});
}
} else if (bodyType === 'form-data') {
// TODO: Handle form-data
axiosConfig.data = body;
axiosConfig.headers['Content-Type'] = 'multipart/form-data';
} else if (bodyType === 'x-www-form-urlencoded') {
axiosConfig.data = body;
axiosConfig.headers['Content-Type'] = 'application/x-www-form-urlencoded';
} else {
// Raw text
axiosConfig.data = body;
axiosConfig.headers['Content-Type'] = 'text/plain';
}
}
const startTime = Date.now();
console.log('axiosConfig:', JSON.stringify(axiosConfig, null, 2));
// Execute the request using the configured axios instance
const response = await axiosInstance(axiosConfig);
const endTime = Date.now();
const responseTime = endTime - startTime;
// Calculate response size
const responseSize = JSON.stringify(response.data).length;
// Log the response
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info(`✅ API Client: Request completed - Status: ${response.status}, Time: ${responseTime}ms, Size: ${responseSize}B`);
// Return structured response
const apiResponse = {
status: response.status,
statusText: response.statusText,
headers: response.headers,
data: response.data,
responseTime,
size: responseSize,
contentType: response.headers['content-type'] || 'unknown',
error: false,
environment: currentEnvironment
};
// Execute post-response script
let postScriptResult = {
success: true
};
if (postScript && postScript.trim()) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.info('🔧 API Client: Executing post-response script');
postScriptResult = await executeScriptSafely(postScript, {
environment: currentEnvironment,
request: {
method,
url,
headers: requestHeaders,
params,
body,
bodyType,
auth
},
response: apiResponse
});
if (!postScriptResult.success) {
apiResponse.postScriptError = postScriptResult.error;
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.warn('⚠️ API Client: Post-response script failed:', postScriptResult.error);
}
apiResponse.environment = postScriptResult.environment;
}
res.json(apiResponse);
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.error('❌ API Client request failed:', error.message);
// Handle axios-specific errors
if (error.response) {
// The request was made and the server responded with a status code
// that falls out of the range of 2xx
return res.json({
status: error.response.status,
statusText: error.response.statusText,
headers: error.response.headers,
data: error.response.data,
responseTime: 0,
size: 0,
contentType: error.response.headers['content-type'] || 'unknown',
error: true,
message: `HTTP ${error.response.status}: ${error.response.statusText}`
});
} else if (error.request) {
// The request was made but no response was received
return res.json({
error: true,
message: 'No response received from server (network error)',
status: 0,
responseTime: 0,
size: 0
});
} else {
// Something happened in setting up the request that triggered an Error
return res.status(500).json({
error: true,
message: error.message || 'Request configuration error',
status: 0,
responseTime: 0,
size: 0
});
}
}
};
/***/ }),
/***/ "./server/controllers/api-client/index.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ HG: () => (/* reexport safe */ _api_client_controller_js__WEBPACK_IMPORTED_MODULE_0__.HG),
/* harmony export */ OV: () => (/* reexport safe */ _api_client_controller_js__WEBPACK_IMPORTED_MODULE_0__.OV),
/* harmony export */ Vc: () => (/* reexport safe */ _api_client_controller_js__WEBPACK_IMPORTED_MODULE_0__.Vc)
/* harmony export */ });
/* harmony import */ var _api_client_controller_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/controllers/api-client/api-client-controller.js");
/***/ }),
/***/ "./server/controllers/chat/chat-controller.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ Ku: () => (/* binding */ getChatStatsHandler),
/* harmony export */ Rq: () => (/* binding */ testChatTemplate),
/* harmony export */ WZ: () => (/* binding */ testChatFunctionalityHandler),
/* harmony export */ _C: () => (/* binding */ checkProviderHealth),
/* harmony export */ b4: () => (/* binding */ getChatConfig),
/* harmony export */ eG: () => (/* binding */ getConversationHistoryHandler),
/* harmony export */ eQ: () => (/* binding */ sendChatMessageStreaming),
/* harmony export */ gJ: () => (/* binding */ sendChatMessage),
/* harmony export */ k6: () => (/* binding */ clearConversationMemoryHandler)
/* harmony export */ });
/* harmony import */ var _services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/controllers/chat/services/chat-service.js");
/* harmony import */ var _processors_streaming_processor_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./server/controllers/chat/processors/streaming-processor.js");
/* harmony import */ var _utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./server/controllers/chat/utils/error-handler.js");
/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./server/logger.js");
/**
* Chat Controller - Main orchestrator for chat operations
* Migrated to functional programming pattern
*/
/**
* Send chat message and get AI response
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function sendChatMessage(req, res) {
try {
const {
message,
conversationHistory = [],
template = 'CHAT_GENERIC',
sessionId
} = req.body;
// Generate response using chat service
const response = await (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .generateChatResponse */ .B5)({
message,
conversationHistory,
options: {
template,
sessionId
}
});
// Send response in standard API format
res.json(response.toApiResponse());
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'sendChatMessage', res);
}
}
/**
* Send chat message with streaming response
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function sendChatMessageStreaming(req, res) {
try {
const {
message,
conversationHistory = [],
template = 'CHAT_GENERIC',
sessionId
} = req.body;
if (!message) {
return res.status(400).json({
success: false,
error: 'Message is required'
});
}
// Set up Server-Sent Events headers
(0,_processors_streaming_processor_js__WEBPACK_IMPORTED_MODULE_1__/* .setupSSEHeaders */ .d5)(res);
// Generate streaming response using chat service
await (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .generateStreamingResponse */ .Pd)({
message,
conversationHistory,
options: {
template,
sessionId
}
}, res);
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.error('Error in streaming chat controller:', error);
// Send error through streaming if headers are already sent
if (res.headersSent) {
(0,_processors_streaming_processor_js__WEBPACK_IMPORTED_MODULE_1__/* .sendError */ .n4)(res, 'Failed to process chat message. Please try again.', 'sendChatMessageStreaming');
} else {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'sendChatMessageStreaming', res);
}
}
res.end();
}
/**
* Get chat configuration and available providers
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function getChatConfig(req, res) {
try {
const {
ChatProviderConfig
} = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "./server/controllers/chat/utils/chat-config.js"));
const config = {
availableProviders: ChatProviderConfig.getAvailableProviders(),
openaiConfigValid: ChatProviderConfig.isOpenAIConfigValid(),
ollamaConfigValid: ChatProviderConfig.isOllamaConfigValid()
};
res.json({
success: true,
data: config
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'getChatConfig', res);
}
}
/**
* Health check for AI providers
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function checkProviderHealth(req, res) {
try {
const {
OllamaService
} = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "./server/controllers/chat/services/ollama-service.js"));
const {
ChatProviderConfig
} = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "./server/controllers/chat/utils/chat-config.js"));
const health = {
openai: {
configured: ChatProviderConfig.isOpenAIConfigValid(),
status: ChatProviderConfig.isOpenAIConfigValid() ? 'ready' : 'not_configured'
},
ollama: {
configured: ChatProviderConfig.isOllamaConfigValid(),
status: 'checking...'
}
};
// Check Ollama availability if configured
if (health.ollama.configured) {
const isAvailable = await OllamaService.isAvailable();
health.ollama.status = isAvailable ? 'ready' : 'unavailable';
} else {
health.ollama.status = 'not_configured';
}
res.json({
success: true,
data: health
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'checkProviderHealth', res);
}
}
/**
* Get conversation history for a session
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function getConversationHistoryHandler(req, res) {
try {
const {
sessionId
} = req.params;
if (!sessionId) {
return res.status(400).json({
success: false,
error: 'Session ID is required'
});
}
const history = await (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .getConversationHistory */ .kP)(sessionId);
res.json({
success: true,
data: {
sessionId,
history
}
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'getConversationHistory', res);
}
}
/**
* Clear conversation memory for a session
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function clearConversationMemoryHandler(req, res) {
try {
const {
sessionId
} = req.params;
if (!sessionId) {
return res.status(400).json({
success: false,
error: 'Session ID is required'
});
}
(0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .clearConversationMemory */ .we)(sessionId);
res.json({
success: true,
data: {
sessionId,
message: 'Conversation memory cleared'
}
});
} catch (error) {
_logger_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.error('Error in clearing conversation memory:', error);
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'clearConversationMemory', res);
}
}
/**
* Test chat with specific template
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function testChatTemplate(req, res) {
try {
const {
template = 'CHAT_GENERIC',
message = 'Hello, can you help me?'
} = req.body;
const result = await (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .testChatFunctionality */ .Mk)(message, null, {
template
});
res.json({
success: true,
data: result
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'testChatTemplate', res);
}
}
/**
* Get chat service statistics
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function getChatStatsHandler(req, res) {
try {
const stats = (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .getChatStats */ .UN)();
res.json({
success: true,
data: stats
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'getChatStats', res);
}
}
/**
* Test chat functionality
* @param {Object} req - Express request object
* @param {Object} res - Express response object
*/
async function testChatFunctionalityHandler(req, res) {
try {
const {
testMessage,
provider
} = req.body;
const result = await (0,_services_chat_service_js__WEBPACK_IMPORTED_MODULE_0__/* .testChatFunctionality */ .Mk)(testMessage, provider);
res.json({
success: true,
data: result
});
} catch (error) {
_utils_error_handler_js__WEBPACK_IMPORTED_MODULE_2__/* .ErrorHandler */ .z.handleApiError(error, 'testChatFunctionality', res);
}
}
/***/ }),
/***/ "./server/controllers/chat/index.js":
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ Ku: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.Ku),
/* harmony export */ Rq: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.Rq),
/* harmony export */ WZ: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.WZ),
/* harmony export */ _C: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__._C),
/* harmony export */ b4: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.b4),
/* harmony export */ eG: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.eG),
/* harmony export */ eQ: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.eQ),
/* harmony export */ gJ: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.gJ),
/* harmony export */ k6: () => (/* reexport safe */ _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__.k6)
/* harmony export */ });
/* harmony import */ var _chat_controller_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./server/controllers/chat/chat-controller.js");
/* harmony import */ var _services_chat_service_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./server/controllers/chat/services/chat-service.js");
/* harmony import */ var _services_openai_service_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./se