@boristype/bt-cli 0.1.0-alpha.0

package/build/core/pushing/index.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Модуль push — загрузка dist на WSHCM сервер и reinit модулей
+ *
+ * Основные экспорты:
+ * - `processPush()` — one-shot push (создаёт сессию, выполняет push, закрывает)
+ * - `DeploySession` — persistent сессия для dev mode
+ * - Утилиты для конфигурации и сбора init-скриптов
+ *
+ * @module core/pushing
+ */
+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.findOnInit = exports.extractOnInitFromXml = exports.resolveXLocalPath = exports.collectStandaloneInitScripts = exports.collectComponentInitScripts = exports.reinitModules = exports.uploadDist = exports.parseBtConfigProperties = exports.resolvePushConnectionOptions = exports.DeploySession = void 0;
+exports.processPush = processPush;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const logger_1 = require("../logger");
+const config_1 = require("./config");
+const session_1 = require("./session");
+/**
+ * Выполняет one-shot push: загрузка dist + reinit модулей
+ *
+ * Создаёт DeploySession, выполняет push и закрывает сессию.
+ * Для persistent использования (dev mode) используйте DeploySession напрямую.
+ *
+ * @param cwd - директория проекта
+ * @param cliOptions - опции подключения из CLI (опциональные)
+ */
+async function processPush(cwd, cliOptions = {}) {
+    const options = (0, config_1.resolvePushConnectionOptions)(cwd, cliOptions);
+    logger_1.logger.info(`🚀 Pushing dist to WSHCM server...`);
+    logger_1.logger.info(`📡 Server: ${options.https ? 'https' : 'http'}://${options.host}:${options.port}`);
+    logger_1.logger.info(`👤 User: ${options.username}`);
+    const distPath = path.join(cwd, 'dist');
+    if (!fs.existsSync(distPath) || !fs.lstatSync(distPath).isDirectory()) {
+        throw new Error(`Папка dist не найдена по пути: ${distPath}`);
+    }
+    const session = new session_1.DeploySession(options);
+    try {
+        await session.initialize();
+        await session.push(distPath);
+        logger_1.logger.info('🎉 Push completed successfully!');
+    }
+    finally {
+        await session.close();
+    }
+}
+// Re-exports
+var session_2 = require("./session");
+Object.defineProperty(exports, "DeploySession", { enumerable: true, get: function () { return session_2.DeploySession; } });
+var config_2 = require("./config");
+Object.defineProperty(exports, "resolvePushConnectionOptions", { enumerable: true, get: function () { return config_2.resolvePushConnectionOptions; } });
+Object.defineProperty(exports, "parseBtConfigProperties", { enumerable: true, get: function () { return config_2.parseBtConfigProperties; } });
+var upload_1 = require("./upload");
+Object.defineProperty(exports, "uploadDist", { enumerable: true, get: function () { return upload_1.uploadDist; } });
+var reinit_1 = require("./reinit");
+Object.defineProperty(exports, "reinitModules", { enumerable: true, get: function () { return reinit_1.reinitModules; } });
+var init_scripts_1 = require("./init-scripts");
+Object.defineProperty(exports, "collectComponentInitScripts", { enumerable: true, get: function () { return init_scripts_1.collectComponentInitScripts; } });
+Object.defineProperty(exports, "collectStandaloneInitScripts", { enumerable: true, get: function () { return init_scripts_1.collectStandaloneInitScripts; } });
+Object.defineProperty(exports, "resolveXLocalPath", { enumerable: true, get: function () { return init_scripts_1.resolveXLocalPath; } });
+Object.defineProperty(exports, "extractOnInitFromXml", { enumerable: true, get: function () { return init_scripts_1.extractOnInitFromXml; } });
+Object.defineProperty(exports, "findOnInit", { enumerable: true, get: function () { return init_scripts_1.findOnInit; } });

package/build/core/pushing/init-scripts.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * Сбор init-скриптов для reinit модулей
+ *
+ * Чистые функции без сетевых вызовов — только работа с файловой системой.
+ *
+ * @module core/pushing/init-scripts
+ */
+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.collectComponentInitScripts = collectComponentInitScripts;
+exports.collectStandaloneInitScripts = collectStandaloneInitScripts;
+exports.resolveXLocalPath = resolveXLocalPath;
+exports.extractOnInitFromXml = extractOnInitFromXml;
+exports.findOnInit = findOnInit;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const xml_1 = require("../utils/xml");
+const logger_1 = require("../logger");
+/**
+ * Собирает init-скрипты из компонентов (директории в dist/components/)
+ *
+ * Для каждой поддиректории генерируется вызов `<componentName>.init()`.
+ *
+ * @param distPath - путь к папке dist
+ * @returns массив init-скриптов компонентов
+ */
+function collectComponentInitScripts(distPath) {
+    const componentsPath = path.join(distPath, 'components');
+    if (!fs.existsSync(componentsPath) || !fs.lstatSync(componentsPath).isDirectory()) {
+        return [];
+    }
+    const result = [];
+    const componentDirs = fs.readdirSync(componentsPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    for (const componentName of componentDirs) {
+        const initCode = `${componentName}.init()`;
+        result.push({ type: 'component', name: componentName, code: initCode });
+    }
+    return result;
+}
+/**
+ * Собирает init-скрипты из standalone модулей (через api_ext.xml)
+ *
+ * Парсит `dist/source/api_ext.xml`, находит API-модули и извлекает
+ * OnInit EXPR из их init XML файлов.
+ *
+ * @param distPath - путь к папке dist
+ * @returns массив init-скриптов standalone модулей
+ */
+function collectStandaloneInitScripts(distPath) {
+    const apiExtPath = path.join(distPath, 'source', 'api_ext.xml');
+    if (!fs.existsSync(apiExtPath)) {
+        return [];
+    }
+    const result = [];
+    const xmlContent = fs.readFileSync(apiExtPath, 'utf-8');
+    const parsed = xml_1.xmlParser.parse(xmlContent);
+    const apis = parsed?.api_ext?.apis?.api;
+    if (!apis) {
+        return [];
+    }
+    // Нормализуем в массив (может быть один объект или массив)
+    const apiList = Array.isArray(apis) ? apis : [apis];
+    for (const api of apiList) {
+        const name = api.name || 'unknown';
+        const libs = api.libs?.lib;
+        if (!libs)
+            continue;
+        const libList = Array.isArray(libs) ? libs : [libs];
+        for (const lib of libList) {
+            const libPath = lib.path;
+            if (!libPath || typeof libPath !== 'string')
+                continue;
+            // Резолвим путь: x-local://wt/myapp/init.xml -> dist/wt/myapp/init.xml
+            const resolvedPath = resolveXLocalPath(distPath, libPath);
+            if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+                logger_1.logger.warning(`⚠️ Init file not found: ${libPath} (resolved: ${resolvedPath})`);
+                continue;
+            }
+            const initCode = extractOnInitFromXml(resolvedPath);
+            if (initCode) {
+                result.push({ type: 'standalone', name, code: initCode });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Резолвит x-local:// путь в локальный путь относительно dist
+ *
+ * @param distPath - путь к папке dist
+ * @param xLocalPath - путь вида "x-local://wt/myapp/init.xml"
+ * @returns локальный путь или null если формат некорректный
+ */
+function resolveXLocalPath(distPath, xLocalPath) {
+    const match = xLocalPath.match(/^x-local:\/\/(.+)$/);
+    if (!match)
+        return null;
+    return path.join(distPath, match[1]);
+}
+/**
+ * Извлекает содержимое OnInit EXPR из XML файла
+ *
+ * @param xmlPath - путь к XML файлу
+ * @returns код из OnInit EXPR атрибута или null
+ */
+function extractOnInitFromXml(xmlPath) {
+    const xmlContent = fs.readFileSync(xmlPath, 'utf-8');
+    const parsed = xml_1.xmlParser.parse(xmlContent);
+    // Ищем OnInit в любом месте структуры
+    const onInit = findOnInit(parsed);
+    if (!onInit)
+        return null;
+    const expr = onInit['@_EXPR'];
+    if (typeof expr === 'string') {
+        return expr.trim();
+    }
+    return null;
+}
+/**
+ * Рекурсивно ищет элемент OnInit в parsed XML
+ *
+ * @param obj - объект для поиска
+ * @returns объект OnInit или null
+ */
+function findOnInit(obj) {
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const record = obj;
+    if ('OnInit' in record && record['OnInit'] && typeof record['OnInit'] === 'object') {
+        return record['OnInit'];
+    }
+    for (const value of Object.values(record)) {
+        const found = findOnInit(value);
+        if (found)
+            return found;
+    }
+    return null;
+}

package/build/core/pushing/queue.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Debounced очередь для push-операций в dev mode
+ *
+ * @module pushing/queue
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebouncedPushQueue = void 0;
+const logger_js_1 = require("../logger.js");
+/**
+ * Простая debounced очередь для push-операций
+ *
+ * Гарантирует что:
+ * - Push не вызывается чаще чем раз в `delayMs` мс
+ * - Если push уже выполняется, новый запрос ставится в очередь
+ * - Одновременно выполняется только один push
+ *
+ * Использует DeploySession для переиспользования одного клиента
+ * и evaluator-а на всё время работы dev mode.
+ */
+class DebouncedPushQueue {
+    /** Таймер debounce */
+    timer = null;
+    /** Флаг: push сейчас выполняется */
+    running = false;
+    /** Флаг: требуется повторный push после текущего */
+    pendingAfterCurrent = false;
+    /** Задержка debounce в мс */
+    delayMs;
+    /** Deploy-сессия (persistent на всё время dev mode) */
+    session;
+    /** Путь к папке dist */
+    distPath;
+    /** Флаг: сессия инициализирована */
+    sessionInitialized = false;
+    /**
+     * @param session - DeploySession для push-операций
+     * @param distPath - путь к папке dist
+     * @param delayMs - задержка debounce в мс
+     */
+    constructor(session, distPath, delayMs = 500) {
+        this.session = session;
+        this.distPath = distPath;
+        this.delayMs = delayMs;
+    }
+    /**
+     * Запланировать push с debounce.
+     * Если push уже идёт — будет выполнен повторно после завершения текущего.
+     */
+    schedule() {
+        if (this.running) {
+            this.pendingAfterCurrent = true;
+            return;
+        }
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => this.execute(), this.delayMs);
+    }
+    /**
+     * Закрывает сессию
+     */
+    async close() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        await this.session.close();
+    }
+    /** Выполнить push */
+    async execute() {
+        this.timer = null;
+        this.running = true;
+        this.pendingAfterCurrent = false;
+        try {
+            // Ленивая инициализация сессии при первом push
+            if (!this.sessionInitialized) {
+                await this.session.initialize();
+                this.sessionInitialized = true;
+            }
+            logger_js_1.logger.info('🚀 Auto-pushing dist to WSHCM server...');
+            await this.session.push(this.distPath);
+            logger_js_1.logger.info('🎉 Auto-push completed successfully!');
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Auto-push failed: ${error.message}`);
+        }
+        this.running = false;
+        if (this.pendingAfterCurrent) {
+            this.pendingAfterCurrent = false;
+            this.schedule();
+        }
+    }
+}
+exports.DebouncedPushQueue = DebouncedPushQueue;

package/build/core/pushing/reinit.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Reinit модулей на WSHCM сервере
+ *
+ * Собирает init-скрипты из dist и выполняет их через evaluator.
+ *
+ * @module core/pushing/reinit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reinitModules = reinitModules;
+const logger_1 = require("../logger");
+const init_scripts_1 = require("./init-scripts");
+/**
+ * Выполняет reinit модулей на сервере
+ *
+ * 1. Собирает init-скрипты из компонентов и standalone модулей
+ * 2. Сбрасывает кеш require (`bt.init_require()`)
+ * 3. Выполняет каждый init-скрипт
+ *
+ * Ошибки отдельных init-скриптов логируются, но не прерывают процесс.
+ * Lifecycle evaluator-а управляется вызывающим кодом.
+ *
+ * @param evaluator - инициализированный evaluator
+ * @param distPath - путь к папке dist
+ */
+async function reinitModules(evaluator, distPath) {
+    logger_1.logger.info('🔄 Collecting init scripts...');
+    const initScripts = [];
+    // 1. Компоненты (первыми, исключая bt-runtime)
+    const componentScripts = (0, init_scripts_1.collectComponentInitScripts)(distPath).filter((script) => script.name !== 'bt-runtime');
+    initScripts.push(...componentScripts);
+    // 2. Standalone модули из api_ext.xml
+    const standaloneScripts = (0, init_scripts_1.collectStandaloneInitScripts)(distPath);
+    initScripts.push(...standaloneScripts);
+    if (initScripts.length === 0) {
+        logger_1.logger.info('ℹ️ No init scripts found');
+        return;
+    }
+    // Вывод найденных скриптов
+    logger_1.logger.info(`📜 Found ${initScripts.length} init script(s):`);
+    for (const script of initScripts) {
+        logger_1.logger.info(`\n${'─'.repeat(60)}`);
+        logger_1.logger.info(`📦 [${script.type}] ${script.name}`);
+        logger_1.logger.info(`${'─'.repeat(60)}`);
+        console.log(script.code);
+    }
+    logger_1.logger.info(`\n${'─'.repeat(60)}`);
+    // Сброс кеша require
+    await evaluator.evalCode("bt.init_require();\nreturn;");
+    // Выполнение init скриптов
+    for (const script of initScripts) {
+        logger_1.logger.info(`⚙️ Executing init for [${script.type}] ${script.name}...`);
+        try {
+            await evaluator.evalCode(script.code + "\nreturn;");
+            logger_1.logger.info(`✅ Successfully executed init for ${script.name}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ Error executing init for ${script.name}: ${error.message}`);
+        }
+    }
+}

package/build/core/pushing/session.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * DeploySession — persistent сессия для push-операций
+ *
+ * Управляет lifecycle одного WshcmClient + Evaluator.
+ * Используется в dev mode для переиспользования соединения между push-ами,
+ * а также в one-shot push через processPush().
+ *
+ * @module core/pushing/session
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploySession = void 0;
+const ws_client_1 = require("@boristype/ws-client");
+const logger_1 = require("../logger");
+const upload_1 = require("./upload");
+const reinit_1 = require("./reinit");
+/**
+ * Persistent сессия для push-операций на WSHCM сервер
+ *
+ * Держит один WshcmClient + один Evaluator на всё время жизни сессии.
+ * Поддерживает reconnect при network-ошибках (1 retry).
+ *
+ * @example
+ * ```typescript
+ * // One-shot
+ * const session = new DeploySession(connectionOptions);
+ * await session.initialize();
+ * await session.push(distPath);
+ * await session.close();
+ *
+ * // Dev mode (persistent)
+ * const session = new DeploySession(connectionOptions);
+ * await session.initialize();
+ * // ... при каждом изменении:
+ * await session.push(distPath);
+ * // ... при завершении:
+ * await session.close();
+ * ```
+ */
+class DeploySession {
+    connectionOptions;
+    client = null;
+    evaluator = null;
+    initialized = false;
+    /**
+     * Создаёт новую deploy-сессию
+     * @param connectionOptions - опции подключения к серверу
+     */
+    constructor(connectionOptions) {
+        this.connectionOptions = connectionOptions;
+    }
+    /**
+     * Инициализирует сессию: создаёт клиент, проверяет авторизацию,
+     * создаёт и инициализирует evaluator.
+     *
+     * Должен быть вызван перед первым push().
+     */
+    async initialize() {
+        this.client = new ws_client_1.WshcmClient({
+            overHttps: this.connectionOptions.https,
+            host: this.connectionOptions.host,
+            port: this.connectionOptions.port,
+            username: this.connectionOptions.username,
+            password: this.connectionOptions.password,
+        });
+        await this.client.initialize();
+        this.evaluator = this.client.createEvaluator();
+        await this.evaluator.initialize();
+        this.initialized = true;
+    }
+    /**
+     * Выполняет push: загрузка dist + reinit модулей
+     *
+     * При network-ошибке пытается выполнить reconnect и повторный push (1 retry).
+     *
+     * @param distPath - путь к папке dist
+     */
+    async push(distPath) {
+        if (!this.initialized || !this.evaluator) {
+            throw new Error('DeploySession is not initialized. Call initialize() first.');
+        }
+        try {
+            await this.executePush(distPath);
+        }
+        catch (error) {
+            if (this.isNetworkError(error)) {
+                logger_1.logger.warning('⚠️ Network error during push, attempting reconnect...');
+                try {
+                    await this.reconnect();
+                    await this.executePush(distPath);
+                }
+                catch (retryError) {
+                    throw new Error(`Push failed after reconnect: ${retryError.message}`);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Закрывает сессию: удаляет evaluator с сервера
+     */
+    async close() {
+        if (this.evaluator) {
+            try {
+                await this.evaluator.close();
+            }
+            catch {
+                // Игнорируем ошибки при закрытии
+            }
+            this.evaluator = null;
+        }
+        this.client = null;
+        this.initialized = false;
+    }
+    /**
+     * Выполняет push без retry-логики
+     */
+    async executePush(distPath) {
+        await (0, upload_1.uploadDist)(this.evaluator, distPath);
+        await (0, reinit_1.reinitModules)(this.evaluator, distPath);
+    }
+    /**
+     * Переподключается к серверу: закрывает текущий evaluator,
+     * создаёт новый и инициализирует его.
+     */
+    async reconnect() {
+        // Закрываем старый evaluator (игнорируем ошибки)
+        if (this.evaluator) {
+            try {
+                await this.evaluator.close();
+            }
+            catch {
+                // Может быть уже недоступен
+            }
+        }
+        // Пересоздаём клиент и evaluator
+        this.client = new ws_client_1.WshcmClient({
+            overHttps: this.connectionOptions.https,
+            host: this.connectionOptions.host,
+            port: this.connectionOptions.port,
+            username: this.connectionOptions.username,
+            password: this.connectionOptions.password,
+        });
+        await this.client.initialize();
+        this.evaluator = this.client.createEvaluator();
+        await this.evaluator.initialize();
+        logger_1.logger.info('🔄 Reconnected to WSHCM server');
+    }
+    /**
+     * Определяет, является ли ошибка сетевой
+     */
+    isNetworkError(error) {
+        if (error instanceof ws_client_1.WshcmException) {
+            const message = error.message.toLowerCase();
+            return message.includes('request failed') ||
+                message.includes('request timed out') ||
+                message.includes('econnrefused') ||
+                message.includes('econnreset') ||
+                message.includes('etimedout') ||
+                message.includes('socket hang up');
+        }
+        return false;
+    }
+}
+exports.DeploySession = DeploySession;

package/build/core/pushing/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Типы для модуля pushing
+ * @module core/pushing/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/pushing/upload.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Загрузка dist на WSHCM сервер
+ *
+ * @module core/pushing/upload
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadDist = uploadDist;
+const ws_client_1 = require("@boristype/ws-client");
+const logger_1 = require("../logger");
+/**
+ * Загружает содержимое dist директории на WSHCM сервер
+ *
+ * Использует переданный evaluator для всех серверных операций.
+ * Lifecycle evaluator-а управляется вызывающим кодом.
+ *
+ * @param evaluator - инициализированный evaluator
+ * @param distPath - путь к папке dist
+ * @param onProgress - callback для отслеживания прогресса загрузки
+ * @returns массив URL загруженных файлов
+ */
+async function uploadDist(evaluator, distPath, onProgress) {
+    const uploader = new ws_client_1.WshcmUploader({
+        evaluator,
+        path: distPath + '/*',
+        destination: 'x-local://',
+    });
+    await uploader.prepare();
+    await uploader.upload(onProgress ?? ((uploaded, total) => {
+        logger_1.logger.info(`📦 Progress: ${(uploaded / total * 100).toFixed(2)}%`);
+    }));
+    const urls = await uploader.finish();
+    logger_1.logger.info(`✅ Uploaded ${urls.length} file(s)`);
+    return urls;
+}