@boristype/bt-cli 0.1.0-alpha.0

package/build/core/linking/utils/node-modules.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Утилиты для копирования node_modules
+ * @module linking/utils/node-modules
+ */
+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.copyNodeModulesWithCache = copyNodeModulesWithCache;
+exports.copyNodeModules = copyNodeModules;
+exports.processPackageDirectory = processPackageDirectory;
+exports.copyPackageContent = copyPackageContent;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const copy_1 = require("./copy");
+/**
+ * Копирует структуру node_modules с поддержкой кэширования
+ *
+ * @param options - Опции копирования
+ * @returns true если копирование было выполнено, false если пропущено (из кэша)
+ *
+ * @remarks
+ * - Проверяет кэш по hash от package-lock.json
+ * - Если hash не изменился - пропускает копирование
+ * - После копирования обновляет кэш
+ */
+function copyNodeModulesWithCache(options) {
+    const { searchDir, targetDir, wsName, cache, logger } = options;
+    // Проверяем нужно ли копировать
+    if (!cache.shouldCopyNodeModules(wsName, searchDir)) {
+        logger.success(`  ├─ node_modules skipped (cached)`);
+        return false;
+    }
+    // Копируем
+    copyNodeModules(searchDir, targetDir);
+    // Обновляем кэш
+    cache.updateNodeModulesCache(wsName, searchDir);
+    logger.success(`  ├─ Copied node_modules`);
+    return true;
+}
+/**
+ * Копирует структуру node_modules из исходной директории в целевую
+ *
+ * @param searchDir - Директория для поиска node_modules
+ * @param targetDir - Директория куда нужно скопировать найденные пакеты
+ *
+ * @remarks
+ * - Копирует только пакеты с свойством `ws:package` в package.json
+ * - Поддерживает scoped packages (@scope/package)
+ * - Пропускает служебные директории, начинающиеся с точки
+ * - Рекурсивно обрабатывает вложенные node_modules
+ */
+function copyNodeModules(searchDir, targetDir) {
+    const nodeModulesPath = path.join(searchDir, 'node_modules');
+    // Проверяем существование node_modules в исходной директории
+    if (!fs.existsSync(nodeModulesPath)) {
+        return;
+    }
+    const targetNodeModulesPath = path.join(targetDir, 'node_modules');
+    // Создаем целевую директорию node_modules если её нет
+    if (!fs.existsSync(targetNodeModulesPath)) {
+        fs.mkdirSync(targetNodeModulesPath, { recursive: true });
+    }
+    // Проходим по всем элементам в node_modules
+    const items = fs.readdirSync(nodeModulesPath);
+    for (const itemName of items) {
+        // Пропускаем служебные директории и файлы (например .bin, .package-lock.json и т.д.)
+        if (itemName.startsWith('.')) {
+            continue;
+        }
+        const sourcePath = path.join(nodeModulesPath, itemName);
+        const targetPath = path.join(targetNodeModulesPath, itemName);
+        // Используем lstat чтобы НЕ следовать по symlink на этапе проверки
+        const lstat = fs.lstatSync(sourcePath);
+        // Если это директория, начинающаяся с @ (scoped packages)
+        if (lstat.isDirectory() && itemName.startsWith('@')) {
+            // Scoped директория - это просто контейнер для пакетов
+            // Создаем её только если в ней будут валидные пакеты
+            const scopedItems = fs.readdirSync(sourcePath);
+            let hasValidPackages = false;
+            for (const scopedItemName of scopedItems) {
+                const scopedSourcePath = path.join(sourcePath, scopedItemName);
+                const scopedTargetPath = path.join(targetPath, scopedItemName);
+                const scopedLstat = fs.lstatSync(scopedSourcePath);
+                if (scopedLstat.isDirectory() || scopedLstat.isSymbolicLink()) {
+                    const copied = processPackageDirectory(scopedSourcePath, scopedTargetPath);
+                    if (copied && !hasValidPackages) {
+                        // Создаем scope директорию при первом успешном копировании
+                        if (!fs.existsSync(targetPath)) {
+                            fs.mkdirSync(targetPath, { recursive: true });
+                        }
+                        hasValidPackages = true;
+                    }
+                }
+            }
+        }
+        // Если это обычная директория или symlink (потенциально пакет)
+        else if (lstat.isDirectory() || lstat.isSymbolicLink()) {
+            processPackageDirectory(sourcePath, targetPath);
+        }
+    }
+}
+/**
+ * Обрабатывает директорию пакета - проверяет наличие ws:package и копирует
+ *
+ * @param packagePath - Путь к пакету (может быть symlink)
+ * @param targetPath - Целевой путь для копирования
+ * @returns true если пакет был скопирован, false иначе
+ *
+ * @remarks
+ * - Следует по symlink для получения реального пути
+ * - Проверяет наличие package.json и свойства ws:package
+ * - Копирует содержимое пакета (исключая вложенный node_modules)
+ * - Рекурсивно обрабатывает вложенные node_modules
+ */
+function processPackageDirectory(packagePath, targetPath) {
+    // Проверяем является ли путь symlink
+    const lstat = fs.lstatSync(packagePath);
+    const isSymlink = lstat.isSymbolicLink();
+    // Получаем реальный путь (следуем по symlink если есть)
+    let realPackagePath;
+    try {
+        realPackagePath = isSymlink ? fs.realpathSync(packagePath) : packagePath;
+    }
+    catch (error) {
+        console.error(`Error resolving path ${packagePath}:`, error);
+        return false;
+    }
+    // Проверяем что это директория
+    const stats = fs.statSync(realPackagePath);
+    if (!stats.isDirectory()) {
+        return false;
+    }
+    // Проверяем наличие package.json
+    const packageJsonPath = path.join(realPackagePath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return false;
+    }
+    // Читаем и парсим package.json
+    let packageJson;
+    try {
+        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (error) {
+        console.error(`Error reading ${packageJsonPath}:`, error);
+        return false;
+    }
+    // Проверяем наличие свойства ws:package
+    const wsPackage = packageJson['ws:package'];
+    if (!wsPackage) {
+        return false;
+    }
+    // Копируем содержимое пакета (кроме вложенного node_modules)
+    copyPackageContent(realPackagePath, targetPath);
+    // Рекурсивно обрабатываем вложенный node_modules
+    copyNodeModules(realPackagePath, targetPath);
+    return true;
+}
+/**
+ * Копирует содержимое пакета, исключая вложенную папку node_modules
+ *
+ * @param sourcePath - Путь к исходному пакету
+ * @param targetPath - Целевой путь
+ *
+ * @remarks
+ * - Исключает директорию node_modules (обрабатывается отдельно)
+ * - Исключает директорию .git
+ * - Рекурсивно копирует все остальные файлы и директории
+ */
+function copyPackageContent(sourcePath, targetPath) {
+    // Создаем целевую директорию
+    if (!fs.existsSync(targetPath)) {
+        fs.mkdirSync(targetPath, { recursive: true });
+    }
+    const items = fs.readdirSync(sourcePath);
+    for (const itemName of items) {
+        // Пропускаем вложенную папку node_modules
+        if (itemName === 'node_modules') {
+            continue;
+        }
+        if (itemName === '.git') {
+            continue;
+        }
+        const itemSourcePath = path.join(sourcePath, itemName);
+        const itemTargetPath = path.join(targetPath, itemName);
+        // Используем statSync чтобы следовать по symlink при копировании содержимого
+        const stats = fs.statSync(itemSourcePath);
+        if (stats.isDirectory()) {
+            (0, copy_1.copyRecursive)(itemSourcePath, itemTargetPath);
+        }
+        else {
+            fs.copyFileSync(itemSourcePath, itemTargetPath);
+        }
+    }
+}

package/build/core/linking/utils/package-type.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Утилиты для работы с типами пакетов
+ * @module linking/utils/package-type
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePackageType = normalizePackageType;
+exports.isExecutablePackageType = isExecutablePackageType;
+exports.getValidPackageTypes = getValidPackageTypes;
+exports.getLegacyPackageTypes = getLegacyPackageTypes;
+exports.formatValidPackageTypes = formatValidPackageTypes;
+/**
+ * Маппинг устаревших типов пакетов на новые
+ * Поддерживает обратную совместимость со старыми конфигурациями
+ */
+const LEGACY_TYPE_MAPPING = {
+    'app': 'standalone',
+    'lib': 'library',
+    'bt': 'system', // bt переименован в system
+};
+/**
+ * Валидные типы пакетов
+ */
+const VALID_PACKAGE_TYPES = ['standalone', 'component', 'library', 'system'];
+/**
+ * Нормализует тип пакета, мапит старые значения на новые для обратной совместимости
+ *
+ * @param wsPackage - значение ws:package из package.json
+ * @returns нормализованный тип или null если не является BT пакетом
+ *
+ * @example
+ * ```ts
+ * normalizePackageType('app')       // -> 'standalone'
+ * normalizePackageType('lib')       // -> 'library'
+ * normalizePackageType('bt')        // -> 'system'
+ * normalizePackageType('standalone') // -> 'standalone'
+ * normalizePackageType(undefined)   // -> null
+ * normalizePackageType('invalid')   // -> null
+ * ```
+ */
+function normalizePackageType(wsPackage) {
+    if (!wsPackage) {
+        return null;
+    }
+    // Проверяем маппинг устаревших типов
+    if (LEGACY_TYPE_MAPPING[wsPackage]) {
+        return LEGACY_TYPE_MAPPING[wsPackage];
+    }
+    // Проверяем валидные типы
+    if (VALID_PACKAGE_TYPES.includes(wsPackage)) {
+        return wsPackage;
+    }
+    return null;
+}
+/**
+ * Проверяет, является ли тип пакета исполняемым (требует полной линковки)
+ *
+ * @param packageType - тип пакета
+ * @returns true если пакет требует полной линковки
+ *
+ * @remarks
+ * - standalone, component, system - полная линковка (node_modules, init.xml/spxml, api_ext.xml)
+ * - library - только копирование в node_modules родительского пакета
+ *
+ * @example
+ * ```ts
+ * isExecutablePackageType('standalone') // -> true
+ * isExecutablePackageType('component')  // -> true
+ * isExecutablePackageType('system')     // -> true
+ * isExecutablePackageType('library')    // -> false
+ * ```
+ */
+function isExecutablePackageType(packageType) {
+    return packageType === 'standalone' || packageType === 'component' || packageType === 'system';
+}
+/**
+ * Возвращает список всех валидных типов пакетов
+ */
+function getValidPackageTypes() {
+    return VALID_PACKAGE_TYPES;
+}
+/**
+ * Возвращает список всех устаревших типов пакетов (для сообщений об ошибках)
+ */
+function getLegacyPackageTypes() {
+    return Object.keys(LEGACY_TYPE_MAPPING);
+}
+/**
+ * Форматирует список валидных типов для вывода в сообщения об ошибках
+ *
+ * @example
+ * ```ts
+ * formatValidPackageTypes()
+ * // -> 'standalone, component, system, library (or legacy: app, lib, bt)'
+ * ```
+ */
+function formatValidPackageTypes() {
+    const validTypes = VALID_PACKAGE_TYPES.join(', ');
+    const legacyTypes = Object.keys(LEGACY_TYPE_MAPPING).join(', ');
+    return `${validTypes} (or legacy: ${legacyTypes})`;
+}

package/build/core/linking/utils/url.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * URL-утилиты для linking
+ *
+ * Функции для работы с x-local:// URL, используемыми в BorisScript среде.
+ * Написаны в стиле BorisScript для совместимости.
+ *
+ * @module linking/utils/url
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlAppenPath = UrlAppenPath;
+/**
+ * Добавляет путь к URL.
+ *
+ * @param url - базовый URL (например `x-local://wt/myapp`)
+ * @param appendPath - путь для добавления (например `init.xml`)
+ * @returns URL с добавленным путём
+ */
+function UrlAppenPath(url, appendPath) {
+    var parsedUrl;
+    var addPath;
+    parsedUrl = BmParseUrl(url);
+    if (!parsedUrl.path.endsWith("/"))
+        parsedUrl.path += '/';
+    addPath = appendPath;
+    if (addPath.charAt(0) == '/')
+        addPath = addPath.slice(1);
+    parsedUrl.path += addPath;
+    return BmParsedUrl__GetStrValue(parsedUrl);
+}
+function BmParseUrl(urlStr) {
+    var obj = {};
+    var tempStr;
+    var pos;
+    tempStr = urlStr;
+    pos = String(tempStr).indexOf(':');
+    if (pos >= 0) {
+        obj.schema = tempStr.slice(0, pos);
+        tempStr = tempStr.slice(pos + 1);
+    }
+    if (tempStr.startsWith('//')) {
+        pos = String(tempStr).indexOf('/', 2);
+        if (pos < 0)
+            pos = tempStr.length;
+        obj.host = tempStr.slice(2, pos);
+        tempStr = tempStr.slice(pos);
+    }
+    if ((pos = String(tempStr).lastIndexOf('#')) > 0) {
+        obj.anchor = tempStr.slice(pos + 1);
+        tempStr = tempStr.slice(0, pos);
+    }
+    if ((pos = String(tempStr).lastIndexOf('?')) > 0) {
+        obj.param = tempStr.slice(pos + 1);
+        tempStr = tempStr.slice(0, pos);
+    }
+    obj.path = tempStr;
+    if (obj.path == "" && obj.host)
+        obj.path = "/";
+    return obj;
+}
+function BmParsedUrl__GetStrValue(url) {
+    var tempStr = "";
+    if (url.schema)
+        tempStr = url.schema + ":";
+    if (url.host || url.schema == "file")
+        tempStr += "//" + url.host;
+    tempStr += url.path;
+    if (url.param)
+        tempStr += "?" + url.param;
+    if (url.fragment)
+        tempStr += "#" + url.fragment;
+    return tempStr;
+}

package/build/core/linking/utils/write.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Утилиты для записи файлов при линковке
+ * @module linking/utils/write
+ */
+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.writeIfChanged = writeIfChanged;
+exports.copyIfChanged = copyIfChanged;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Записывает файл только если содержимое изменилось
+ *
+ * Сравнивает новое содержимое с существующим файлом.
+ * Если файл не существует или содержимое отличается — записывает.
+ * Автоматически создаёт директории.
+ *
+ * @param filePath - Путь к файлу
+ * @param content - Новое содержимое
+ * @returns true если файл был записан, false если содержимое не изменилось
+ *
+ * @example
+ * ```typescript
+ * if (writeIfChanged('dist/api_ext.xml', newContent)) {
+ *   logger.info('api_ext.xml updated');
+ * }
+ * ```
+ */
+function writeIfChanged(filePath, content) {
+    if (fs.existsSync(filePath)) {
+        const existing = fs.readFileSync(filePath, 'utf-8');
+        if (existing === content) {
+            return false;
+        }
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return true;
+}
+/**
+ * Копирует файл только если содержимое изменилось
+ *
+ * @param srcPath - Путь к исходному файлу
+ * @param dstPath - Путь к целевому файлу
+ * @returns true если файл был скопирован, false если содержимое не изменилось
+ */
+function copyIfChanged(srcPath, dstPath) {
+    const content = fs.readFileSync(srcPath);
+    if (fs.existsSync(dstPath)) {
+        const existing = fs.readFileSync(dstPath);
+        if (content.equals(existing)) {
+            return false;
+        }
+    }
+    fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+    fs.copyFileSync(srcPath, dstPath);
+    return true;
+}

package/build/core/logger.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+/**
+ * Re-export логгера из utils для обратной совместимости импортов.
+ * Основная реализация: {@link ./utils/logger.ts}
+ * @module core/logger
+ */
+var logger_js_1 = require("./utils/logger.js");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_js_1.logger; } });

package/build/core/pushing/config.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Конфигурация подключения для push
+ *
+ * Парсинг btconfig.properties и мерж опций с приоритетом:
+ * CLI > btconfig.properties > defaults
+ *
+ * @module core/pushing/config
+ */
+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.parseBtConfigProperties = parseBtConfigProperties;
+exports.resolvePushConnectionOptions = resolvePushConnectionOptions;
+const path = __importStar(require("node:path"));
+const properties_1 = require("../utils/properties");
+/**
+ * Дефолтные значения для подключения к WSHCM серверу
+ */
+const DEFAULTS = {
+    https: false,
+    host: 'localhost',
+    port: 80,
+    username: 'user1',
+    password: 'user1',
+};
+/**
+ * Парсит файл btconfig.properties
+ *
+ * @param cwd - директория проекта
+ * @returns частичные опции подключения
+ */
+function parseBtConfigProperties(cwd) {
+    const result = (0, properties_1.parsePropertiesFile)(path.join(cwd, 'btconfig.properties'));
+    return {
+        https: result['https'] === 'true' ? true : undefined,
+        host: result['host'] || undefined,
+        port: result['port'] ? parseInt(result['port'], 10) : undefined,
+        username: result['username'] || undefined,
+        password: result['password'] || undefined,
+    };
+}
+/**
+ * Резолвит опции подключения с приоритетом: CLI > btconfig.properties > defaults
+ *
+ * @param cwd - директория проекта (для чтения btconfig.properties)
+ * @param cliOptions - опции из CLI (наивысший приоритет)
+ * @returns полные опции подключения с заполненными дефолтами
+ */
+function resolvePushConnectionOptions(cwd, cliOptions = {}) {
+    const configOptions = parseBtConfigProperties(cwd);
+    return {
+        https: cliOptions.https ?? configOptions.https ?? DEFAULTS.https,
+        host: cliOptions.host ?? configOptions.host ?? DEFAULTS.host,
+        port: cliOptions.port ?? configOptions.port ?? DEFAULTS.port,
+        username: cliOptions.username ?? configOptions.username ?? DEFAULTS.username,
+        password: cliOptions.password ?? configOptions.password ?? DEFAULTS.password,
+    };
+}