@boristype/bt-cli 0.1.0-alpha.0

package/build/wshcm/client.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WshcmClient = void 0;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const exceptions_1 = require("./exceptions");
+const soap_utils_1 = require("./soap-utils");
+const evaluator_1 = require("./evaluator");
+// ============================================================================
+// Main WSHCM Client
+// ============================================================================
+/** Таймаут HTTP-запросов по умолчанию (30 секунд) */
+const DEFAULT_REQUEST_TIMEOUT = 30_000;
+/**
+ * Клиент для работы с WebSoft HCM через SP-XML API
+ *
+ * @example
+ * ```typescript
+ * const client = new WshcmClient({
+ *   overHttps: false,
+ *   host: 'localhost',
+ *   port: 8080,
+ *   username: 'admin',
+ *   password: 'password'
+ * });
+ *
+ * await client.initialize();
+ * const result = await client.callMethod<string>('tools', 'some_method', ['arg1', 'arg2']);
+ *
+ * const evaluator = client.createEvaluator();
+ * await evaluator.initialize();
+ * // ... use evaluator ...
+ * await evaluator.close();
+ * ```
+ */
+class WshcmClient {
+    baseUrl;
+    username;
+    password;
+    cookies = [];
+    isHttps;
+    requestTimeout;
+    /**
+     * Создает новый экземпляр WSHCM-клиента
+     * @param options - опции подключения
+     */
+    constructor(options) {
+        this.isHttps = options.overHttps;
+        this.baseUrl = `${options.overHttps ? 'https' : 'http'}://${options.host}:${options.port}`;
+        this.username = options.username;
+        this.password = options.password;
+        this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    }
+    /**
+     * Инициализирует клиент и проверяет авторизацию
+     * Должен быть вызван после создания экземпляра
+     */
+    async initialize() {
+        const statusCode = await this.makeRequest('/spxml_web/main.htm', 'GET');
+        if (statusCode !== 200) {
+            throw new exceptions_1.UnauthorizedError();
+        }
+    }
+    /**
+     * Вызывает метод через SP-XML API
+     * @template T - тип возвращаемого значения
+     * @param lib - библиотека/модуль (например, "tools", или URL модуля)
+     * @param method - имя метода
+     * @param methodArgs - массив аргументов метода
+     * @returns результат выполнения метода
+     */
+    async callMethod(lib, method, methodArgs = []) {
+        const headers = {
+            'accept': '*/*',
+            'accept-language': 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7',
+            'cache-control': 'no-cache',
+            'content-type': 'application/soap+xml; charset=UTF-8',
+            'pragma': 'no-cache',
+            'x-spxml-client': 'SP-XML Web client 1.0',
+        };
+        const body = (0, soap_utils_1.renderRequest)(lib, method, methodArgs);
+        const responseText = await this.makeRequest('/api/spxml/CallMethod', 'POST', headers, body);
+        return (0, soap_utils_1.parseResponse)(responseText);
+    }
+    /**
+     * Создаёт новый Evaluator для выполнения произвольного кода на сервере.
+     *
+     * Вызывающий код отвечает за lifecycle evaluator-а:
+     * вызов `initialize()` перед использованием и `close()` после завершения.
+     *
+     * @returns новый экземпляр Evaluator
+     */
+    createEvaluator() {
+        return new evaluator_1.Evaluator(this);
+    }
+    /**
+     * Выполняет HTTP-запрос
+     * @param path - путь запроса
+     * @param method - HTTP-метод
+     * @param headers - заголовки
+     * @param body - тело запроса
+     * @returns статус-код или тело ответа
+     */
+    makeRequest(path, method, headers = {}, body) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.baseUrl + path);
+            const auth = Buffer.from(`${this.username}:${this.password}`).toString('base64');
+            const allHeaders = {
+                ...headers,
+                'Authorization': `Basic ${auth}`,
+            };
+            if (this.cookies.length > 0) {
+                allHeaders['Cookie'] = this.cookies.join('; ');
+            }
+            if (body) {
+                allHeaders['Content-Length'] = Buffer.byteLength(body).toString();
+            }
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname + url.search,
+                method: method,
+                headers: allHeaders,
+                timeout: this.requestTimeout,
+            };
+            const lib = this.isHttps ? https : http;
+            const req = lib.request(options, (res) => {
+                // Сохраняем cookies
+                const setCookie = res.headers['set-cookie'];
+                if (setCookie) {
+                    this.cookies.push(...setCookie.map(cookie => cookie.split(';')[0]));
+                }
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    if (method === 'GET') {
+                        resolve(res.statusCode || 500);
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new exceptions_1.WshcmException(`Request timed out after ${this.requestTimeout}ms: ${method} ${path}`));
+            });
+            req.on('error', (error) => {
+                reject(new exceptions_1.WshcmException(`Request failed: ${error.message}`));
+            });
+            if (body) {
+                req.write(body);
+            }
+            req.end();
+        });
+    }
+}
+exports.WshcmClient = WshcmClient;

package/build/wshcm/evaluator.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+/**
+ * Evaluator для выполнения произвольного BorisScript-кода на сервере
+ *
+ * Создает временный модуль на сервере с функциями execute и drop_self,
+ * позволяя выполнять динамический код через eval.
+ *
+ * @example
+ * ```typescript
+ * const evaluator = client.evaluator;
+ * await evaluator.initialize();
+ * const result = await evaluator.eval('return 2 + 2;');
+ * await evaluator.close();
+ * ```
+ */
+class Evaluator {
+    client;
+    evalKey;
+    libUrl;
+    initialized = false;
+    /**
+     * Создает новый evaluator
+     * @param client - экземпляр WshcmClient
+     */
+    constructor(client) {
+        this.client = client;
+        this.evalKey = 'unsafe_eval_' + this.generateRandomString(32);
+        this.libUrl = `x-local://wt/${this.evalKey}.bs`;
+    }
+    /**
+     * Инициализирует evaluator, создавая временный модуль на сервере
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        const content = this.getUnsafeEvalScript();
+        await this.client.callMethod('tools', 'put_url_text_server', [this.libUrl, content]);
+        this.initialized = true;
+    }
+    /**
+     * Выполняет произвольный BorisScript-код на сервере
+     * @param code - код для выполнения
+     * @returns результат выполнения
+     */
+    async eval(code) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        return this.client.callMethod(this.libUrl, 'execute', [code]);
+    }
+    async evalCode(code) {
+        // Оборачиваем код в функцию, чтобы явно не возвращать никакого результата всего сегмента кода, даже если в коде есть return
+        const randomFuncName = '__evaluator_wrapper_' + this.generateRandomString(32);
+        const wrappedCode = `function ${randomFuncName}() {\n${code}\n}\n${randomFuncName}();return;`;
+        return this.eval(wrappedCode);
+    }
+    async evalExpr(expr) {
+        return this.eval(expr);
+    }
+    /**
+     * Закрывает evaluator и удаляет временный модуль с сервера
+     * @returns true если удаление успешно, false в противном случае
+     */
+    async close() {
+        if (!this.initialized) {
+            return false;
+        }
+        try {
+            const result = await this.client.callMethod(this.libUrl, 'drop_self', []);
+            this.initialized = false;
+            return result;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Генерирует случайную строку заданной длины
+     */
+    generateRandomString(length) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+    /**
+     * Возвращает содержимое временного модуля unsafe_eval.bs
+     */
+    getUnsafeEvalScript() {
+        return `"META:ALLOW-CALL-FROM-CLIENT:1"
+function execute(code) {
+    return eval(code);
+}
+
+"META:ALLOW-CALL-FROM-CLIENT:1"
+function drop_self() {
+    try {
+        DeleteFile("${this.libUrl}");
+        return true;
+    } catch (err) {
+        return false;
+    }
+}`;
+    }
+}
+exports.Evaluator = Evaluator;

package/build/wshcm/exceptions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedError = exports.WshcmException = void 0;
+/**
+ * Базовое исключение для WSHCM-клиента
+ */
+class WshcmException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WshcmException';
+        Object.setPrototypeOf(this, WshcmException.prototype);
+    }
+}
+exports.WshcmException = WshcmException;
+/**
+ * Исключение при ошибке авторизации
+ */
+class UnauthorizedError extends WshcmException {
+    constructor(message = 'Unauthorized') {
+        super(message);
+        this.name = 'UnauthorizedError';
+        Object.setPrototypeOf(this, UnauthorizedError.prototype);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;

package/build/wshcm/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * WSHCM Client - клиент для работы с WebSoft HCM через SP-XML API
+ *
+ * @module wshcm
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WshcmUploader = exports.parseResponse = exports.renderRequest = exports.UnauthorizedError = exports.WshcmException = exports.Evaluator = exports.WshcmClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "WshcmClient", { enumerable: true, get: function () { return client_1.WshcmClient; } });
+var evaluator_1 = require("./evaluator");
+Object.defineProperty(exports, "Evaluator", { enumerable: true, get: function () { return evaluator_1.Evaluator; } });
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "WshcmException", { enumerable: true, get: function () { return exceptions_1.WshcmException; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return exceptions_1.UnauthorizedError; } });
+var soap_utils_1 = require("./soap-utils");
+Object.defineProperty(exports, "renderRequest", { enumerable: true, get: function () { return soap_utils_1.renderRequest; } });
+Object.defineProperty(exports, "parseResponse", { enumerable: true, get: function () { return soap_utils_1.parseResponse; } });
+var uploader_1 = require("./uploader");
+Object.defineProperty(exports, "WshcmUploader", { enumerable: true, get: function () { return uploader_1.WshcmUploader; } });

package/build/wshcm/soap-utils.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRequest = renderRequest;
+exports.parseResponse = parseResponse;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const exceptions_1 = require("./exceptions");
+// ============================================================================
+// XML Parser / Builder instances
+// ============================================================================
+/**
+ * XMLParser для SOAP-ответов.
+ * `removeNSPrefix: true` убирает namespace-префиксы (soap:Envelope → Envelope),
+ * что позволяет обращаться к элементам напрямую без привязки к префиксам сервера.
+ */
+const soapParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    removeNSPrefix: true,
+    trimValues: true,
+});
+/**
+ * XMLBuilder для формирования SOAP-запросов.
+ * Автоматически экранирует XML-сущности в значениях и атрибутах.
+ */
+const soapBuilder = new fast_xml_parser_1.XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    format: true,
+    indentBy: '    ',
+    suppressEmptyNode: false,
+    processEntities: true,
+});
+// ============================================================================
+// Request Building
+// ============================================================================
+/**
+ * Преобразует аргумент метода в объект для XMLBuilder
+ * @param arg - значение аргумента
+ * @returns объект с VALUE-TYPE атрибутом и текстовым содержимым
+ */
+function buildArgumentValue(arg) {
+    if (typeof arg === 'string') {
+        return {
+            '@_VALUE-TYPE': 'string',
+            '#text': arg
+        };
+    }
+    if (typeof arg === 'number') {
+        return {
+            '@_VALUE-TYPE': Number.isInteger(arg) ? 'integer' : 'real',
+            '#text': arg,
+        };
+    }
+    if (typeof arg === 'boolean') {
+        return {
+            '@_VALUE-TYPE': 'bool',
+            '#text': arg ? 1 : 0
+        };
+    }
+    if (arg === null || arg === undefined) {
+        return { '@_VALUE-TYPE': 'string', '#text': '' };
+    }
+    // Для объектов и массивов — неподдерживаемый тип, используем JSON как строку
+    try {
+        return { '@_VALUE-TYPE': 'string', '#text': JSON.stringify(arg) };
+    }
+    catch {
+        throw new exceptions_1.WshcmException('Unsupported argument type');
+    }
+}
+/**
+ * Рендерит SOAP-запрос для вызова метода
+ * @param lib - библиотека/модуль
+ * @param method - имя метода
+ * @param methodArgs - аргументы метода
+ * @returns XML-строка SOAP-запроса
+ */
+function renderRequest(lib, method, methodArgs) {
+    const argData = {};
+    for (let i = 0; i < methodArgs.length; i++) {
+        argData[`arg-${i}`] = buildArgumentValue(methodArgs[i]);
+    }
+    const requestObj = {
+        '?xml': { '@_version': '1.0', '@_encoding': 'utf-8' },
+        'soap:Envelope': {
+            '@_xmlns:soap': 'http://schemas.xmlsoap.org/soap/envelope/',
+            '@_xmlns': 'http://www.datex-soft.com/soap/',
+            'soap:Body': {
+                'CallMethod': {
+                    'LibName': lib,
+                    'MethodName': method,
+                    'ArgData': argData,
+                },
+            },
+        },
+    };
+    return soapBuilder.build(requestObj);
+}
+// ============================================================================
+// Response Parsing
+// ============================================================================
+/**
+ * Рекурсивно ищет элемент по имени в распарсенном XML-объекте.
+ * Аналог SimpleXmlParser.findElement — ищет ключ на любом уровне вложенности.
+ *
+ * @param obj - распарсенный XML-объект
+ * @param key - имя искомого элемента
+ * @returns найденный элемент или undefined
+ */
+function findElement(obj, key) {
+    if (!obj || typeof obj !== 'object')
+        return undefined;
+    const record = obj;
+    if (key in record)
+        return record[key];
+    for (const val of Object.values(record)) {
+        const found = findElement(val, key);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Парсит значение элемента на основе VALUE-TYPE атрибута.
+ *
+ * fast-xml-parser представляет элемент с атрибутами как объект:
+ * - `@_VALUE-TYPE` — тип значения
+ * - `#text` — текстовое содержимое (может отсутствовать для пустых элементов)
+ * - остальные ключи — дочерние элементы (для Object/Array типов)
+ *
+ * @param element - распарсенный XML-элемент
+ * @returns JS-значение соответствующего типа
+ */
+function parseResultValue(element) {
+    if (element === undefined || element === null)
+        return undefined;
+    // Если элемент — примитив (нет атрибутов), вернуть как есть
+    if (typeof element !== 'object')
+        return element;
+    const valueType = element['@_VALUE-TYPE'];
+    if (!valueType || valueType === 'undefined' || valueType === 'null') {
+        return undefined;
+    }
+    if (valueType === 'string') {
+        const text = element['#text'];
+        return text != null ? String(text) : '';
+    }
+    if (valueType === 'integer') {
+        return parseInt(String(element['#text'] ?? '0'), 10);
+    }
+    if (valueType === 'real') {
+        return parseFloat(String(element['#text'] ?? '0'));
+    }
+    if (valueType === 'bool') {
+        return (element['#text'] ?? 0) == 1;
+    }
+    if (valueType === 'Object') {
+        return parseResultObject(element);
+    }
+    if (valueType === 'Array') {
+        return parseResultArray(element);
+    }
+    throw new exceptions_1.WshcmException(`Unexpected VALUE-TYPE: ${valueType}`);
+}
+/**
+ * Парсит объект из распарсенного XML-элемента.
+ * Итерирует дочерние ключи (исключая `@_*` атрибуты и `#text`),
+ * рекурсивно разбирая каждый через {@link parseResultValue}.
+ *
+ * @param element - элемент с `@_VALUE-TYPE="Object"`
+ * @returns JS-объект
+ */
+function parseResultObject(element) {
+    const result = {};
+    for (const [key, value] of Object.entries(element)) {
+        if (key.startsWith('@_') || key === '#text')
+            continue;
+        result[key] = parseResultValue(value);
+    }
+    return result;
+}
+/**
+ * Парсит массив из распарсенного XML-элемента.
+ * Итерирует дочерние ключи (исключая `@_*` атрибуты и `#text`),
+ * рекурсивно разбирая каждый через {@link parseResultValue}.
+ *
+ * @param element - элемент с `@_VALUE-TYPE="Array"`
+ * @returns JS-массив
+ */
+function parseResultArray(element) {
+    const result = [];
+    for (const [key, value] of Object.entries(element)) {
+        if (key.startsWith('@_') || key === '#text')
+            continue;
+        result.push(parseResultValue(value));
+    }
+    return result;
+}
+/**
+ * Парсит SOAP-ответ и извлекает результат.
+ *
+ * Использует `fast-xml-parser` с `removeNSPrefix: true` для прозрачной
+ * работы с namespace-префиксами (soap:Envelope → Envelope и т.д.).
+ *
+ * @param responseText - XML-строка ответа
+ * @returns результат выполнения метода
+ */
+function parseResponse(responseText) {
+    const parsed = soapParser.parse(responseText);
+    // Проверяем на ошибку SOAP Fault
+    const fault = findElement(parsed, 'Fault');
+    if (fault && typeof fault === 'object') {
+        const errorCode = fault.faultcode ?? 'UNKNOWN';
+        const errorMessage = fault.faultstring ?? 'Unknown error';
+        throw new exceptions_1.WshcmException(`ERR: (${errorCode}) ${errorMessage}`);
+    }
+    // Ищем ResultData
+    const resultData = findElement(parsed, 'ResultData');
+    if (!resultData) {
+        return undefined;
+    }
+    // Ищем Result внутри ResultData
+    const result = typeof resultData === 'object' ? resultData.Result : undefined;
+    if (result === undefined) {
+        throw new exceptions_1.WshcmException('Unexpected response: Result element not found');
+    }
+    return parseResultValue(result);
+}

package/build/wshcm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });