@xcanwin/manyoyo 5.8.6 → 5.8.10

package/lib/json5-text-edit.js

@@ -0,0 +1,238 @@
+'use strict';
+
+function readQuotedString(text, startIndex) {
+    const quote = text[startIndex];
+    let value = '';
+
+    for (let i = startIndex + 1; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '\\') {
+            value += ch;
+            if (i + 1 < text.length) {
+                value += text[i + 1];
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === quote) {
+            return {
+                value,
+                end: i + 1
+            };
+        }
+        value += ch;
+    }
+
+    return null;
+}
+
+function isIdentifierStart(ch) {
+    return /[A-Za-z_$]/.test(ch);
+}
+
+function isIdentifierPart(ch) {
+    return /[A-Za-z0-9_$]/.test(ch);
+}
+
+function skipTrivia(text, index) {
+    let cursor = index;
+    while (cursor < text.length) {
+        const ch = text[cursor];
+        const next = text[cursor + 1];
+        if (/\s/.test(ch)) {
+            cursor += 1;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            cursor += 2;
+            while (cursor < text.length && text[cursor] !== '\n') {
+                cursor += 1;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            cursor += 2;
+            while (cursor + 1 < text.length && !(text[cursor] === '*' && text[cursor + 1] === '/')) {
+                cursor += 1;
+            }
+            cursor = cursor + 1 < text.length ? cursor + 2 : text.length;
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+
+function scanValueEnd(text, startIndex) {
+    let cursor = startIndex;
+    let stringQuote = '';
+    let lineComment = false;
+    let blockComment = false;
+    let depth = 0;
+
+    for (; cursor < text.length; cursor += 1) {
+        const ch = text[cursor];
+        const next = text[cursor + 1];
+
+        if (lineComment) {
+            if (ch === '\n') {
+                lineComment = false;
+            }
+            continue;
+        }
+        if (blockComment) {
+            if (ch === '*' && next === '/') {
+                blockComment = false;
+                cursor += 1;
+            }
+            continue;
+        }
+        if (stringQuote) {
+            if (ch === '\\') {
+                cursor += 1;
+                continue;
+            }
+            if (ch === stringQuote) {
+                stringQuote = '';
+            }
+            continue;
+        }
+
+        if (ch === '/' && next === '/') {
+            lineComment = true;
+            cursor += 1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            blockComment = true;
+            cursor += 1;
+            continue;
+        }
+        if (ch === '"' || ch === '\'') {
+            stringQuote = ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[' || ch === '(') {
+            depth += 1;
+            continue;
+        }
+        if (ch === '}' || ch === ']' || ch === ')') {
+            if (depth === 0) {
+                break;
+            }
+            depth -= 1;
+            continue;
+        }
+        if (depth === 0 && ch === ',') {
+            break;
+        }
+    }
+
+    let end = cursor;
+    while (end > startIndex && /\s/.test(text[end - 1])) {
+        end -= 1;
+    }
+    return end;
+}
+
+function findRootObjectStart(text) {
+    const source = String(text || '');
+    const start = skipTrivia(source, 0);
+    return source[start] === '{' ? start : -1;
+}
+
+function readPropertyToken(text, startIndex) {
+    const ch = text[startIndex];
+    if (ch === '"' || ch === '\'') {
+        return readQuotedString(text, startIndex);
+    }
+    if (!isIdentifierStart(ch)) {
+        return null;
+    }
+
+    let end = startIndex + 1;
+    while (end < text.length && isIdentifierPart(text[end])) {
+        end += 1;
+    }
+    return {
+        value: text.slice(startIndex, end),
+        end
+    };
+}
+
+function findObjectPropertyValueRange(text, objectStartIndex, propertyName) {
+    let cursor = skipTrivia(text, objectStartIndex + 1);
+    while (cursor < text.length) {
+        cursor = skipTrivia(text, cursor);
+        if (text[cursor] === '}') {
+            return null;
+        }
+        const token = readPropertyToken(text, cursor);
+        if (!token) {
+            return null;
+        }
+        cursor = skipTrivia(text, token.end);
+        if (text[cursor] !== ':') {
+            return null;
+        }
+        const valueStart = skipTrivia(text, cursor + 1);
+        const valueEnd = scanValueEnd(text, valueStart);
+        if (token.value === propertyName) {
+            return { start: valueStart, end: valueEnd };
+        }
+        cursor = skipTrivia(text, valueEnd);
+        if (text[cursor] === ',') {
+            cursor += 1;
+            continue;
+        }
+        if (text[cursor] === '}') {
+            return null;
+        }
+    }
+    return null;
+}
+
+function findValueRangeByPath(text, pathParts) {
+    if (!Array.isArray(pathParts) || pathParts.length === 0) {
+        return null;
+    }
+
+    let objectStart = findRootObjectStart(text);
+    if (objectStart === -1) {
+        return null;
+    }
+
+    let range = null;
+    for (let i = 0; i < pathParts.length; i += 1) {
+        range = findObjectPropertyValueRange(text, objectStart, pathParts[i]);
+        if (!range) {
+            return null;
+        }
+        if (i === pathParts.length - 1) {
+            return range;
+        }
+        const nextObjectStart = skipTrivia(text, range.start);
+        if (text[nextObjectStart] !== '{') {
+            return null;
+        }
+        objectStart = nextObjectStart;
+    }
+    return range;
+}
+
+function findTopLevelPropertyValueRange(text, propertyName) {
+    return findValueRangeByPath(text, [propertyName]);
+}
+
+function applyTextReplacements(text, replacements) {
+    return replacements
+        .slice()
+        .sort((a, b) => b.start - a.start)
+        .reduce((result, item) => `${result.slice(0, item.start)}${item.text}${result.slice(item.end)}`, text);
+}
+
+module.exports = {
+    findTopLevelPropertyValueRange,
+    findValueRangeByPath,
+    applyTextReplacements
+};

package/lib/runtime-normalizers.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+function parseEnvEntry(entryText) {
+    const text = String(entryText || '');
+    const idx = text.indexOf('=');
+    if (idx <= 0) {
+        throw new Error(`env 格式应为 KEY=VALUE: ${text}`);
+    }
+
+    const key = text.slice(0, idx);
+    const value = text.slice(idx + 1);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        throw new Error(`env key 非法: ${key}`);
+    }
+    if (/[\r\n\0]/.test(value) || /[;&|`$<>]/.test(value)) {
+        throw new Error(`env value 含非法字符: ${key}`);
+    }
+
+    return { key, value };
+}
+
+function expandHomeAliasPath(filePath, homeDir = os.homedir()) {
+    const text = String(filePath || '').trim();
+    if (!text) {
+        return text;
+    }
+    if (text === '~') {
+        return homeDir;
+    }
+    if (text.startsWith('~/')) {
+        return path.join(homeDir, text.slice(2));
+    }
+    if (text === '$HOME') {
+        return homeDir;
+    }
+    if (text.startsWith('$HOME/')) {
+        return path.join(homeDir, text.slice('$HOME/'.length));
+    }
+    return text;
+}
+
+function normalizeVolume(volume, homeDir = os.homedir()) {
+    const text = String(volume || '').trim();
+    if (!text.startsWith('~') && !text.startsWith('$HOME')) {
+        return text;
+    }
+
+    const separatorIndex = text.indexOf(':');
+    if (separatorIndex === -1) {
+        return expandHomeAliasPath(text, homeDir);
+    }
+
+    const hostPath = text.slice(0, separatorIndex);
+    const rest = text.slice(separatorIndex);
+    return `${expandHomeAliasPath(hostPath, homeDir)}${rest}`;
+}
+
+module.exports = {
+    parseEnvEntry,
+    expandHomeAliasPath,
+    normalizeVolume
+};

package/lib/runtime-resolver.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function toArray(value) {
+    return Array.isArray(value) ? value : (value ? [value] : []);
+}
+
+function resolveRuntimeConfig(options = {}) {
+    const params = options;
+    const cliOptions = params.cliOptions || {};
+    const globalConfig = params.globalConfig || {};
+    const runConfig = params.runConfig || {};
+    const globalFirstConfig = params.globalFirstConfig || {};
+    const runFirstConfig = params.runFirstConfig || {};
+    const defaults = params.defaults || {};
+    const envVars = params.envVars || process.env;
+    const pickConfigValue = params.pickConfigValue;
+    const resolveContainerNameTemplate = params.resolveContainerNameTemplate;
+    const normalizeCommandSuffix = params.normalizeCommandSuffix;
+    const normalizeJsonEnvMap = params.normalizeJsonEnvMap;
+    const normalizeCliEnvMap = params.normalizeCliEnvMap;
+    const mergeArrayConfig = params.mergeArrayConfig;
+    const normalizeVolume = params.normalizeVolume;
+    const parseServerListen = params.parseServerListen;
+    const argv = Array.isArray(params.argv) ? params.argv : [];
+    const isServerMode = params.isServerMode === true;
+    const isServerStopMode = params.isServerStopMode === true;
+
+    let hostPath = pickConfigValue(cliOptions.hostPath, runConfig.hostPath, globalConfig.hostPath, defaults.hostPath) || defaults.hostPath;
+    let containerName = defaults.containerName;
+    const mergedContainerName = pickConfigValue(cliOptions.contName, runConfig.containerName, globalConfig.containerName);
+    if (mergedContainerName) {
+        containerName = mergedContainerName;
+    }
+    containerName = resolveContainerNameTemplate(containerName);
+
+    let containerPath = defaults.containerPath;
+    const mergedContainerPath = pickConfigValue(cliOptions.contPath, runConfig.containerPath, globalConfig.containerPath);
+    if (mergedContainerPath) {
+        containerPath = mergedContainerPath;
+    }
+
+    const imageName = pickConfigValue(cliOptions.imageName, runConfig.imageName, globalConfig.imageName, defaults.imageName) || defaults.imageName;
+    const imageVersion = pickConfigValue(cliOptions.imageVer, runConfig.imageVersion, globalConfig.imageVersion, defaults.imageVersion) || defaults.imageVersion;
+
+    let execPrefix = '';
+    const mergedShellPrefix = pickConfigValue(cliOptions.shellPrefix, runConfig.shellPrefix, globalConfig.shellPrefix);
+    if (mergedShellPrefix) {
+        execPrefix = `${mergedShellPrefix} `;
+    }
+
+    let execShell = '';
+    const mergedShell = pickConfigValue(cliOptions.shell, runConfig.shell, globalConfig.shell);
+    if (mergedShell) {
+        execShell = mergedShell;
+    }
+
+    let execSuffix = '';
+    const mergedShellSuffix = pickConfigValue(cliOptions.shellSuffix, runConfig.shellSuffix, globalConfig.shellSuffix);
+    if (mergedShellSuffix) {
+        execSuffix = normalizeCommandSuffix(mergedShellSuffix);
+    }
+
+    let firstExecPrefix = '';
+    const mergedFirstShellPrefix = pickConfigValue(cliOptions.firstShellPrefix, runFirstConfig.shellPrefix, globalFirstConfig.shellPrefix);
+    if (mergedFirstShellPrefix) {
+        firstExecPrefix = `${mergedFirstShellPrefix} `;
+    }
+
+    let firstExecShell = '';
+    const mergedFirstShell = pickConfigValue(cliOptions.firstShell, runFirstConfig.shell, globalFirstConfig.shell);
+    if (mergedFirstShell) {
+        firstExecShell = mergedFirstShell;
+    }
+
+    let firstExecSuffix = '';
+    const mergedFirstShellSuffix = pickConfigValue(cliOptions.firstShellSuffix, runFirstConfig.shellSuffix, globalFirstConfig.shellSuffix);
+    if (mergedFirstShellSuffix) {
+        firstExecSuffix = normalizeCommandSuffix(mergedFirstShellSuffix);
+    }
+
+    const envFile = [
+        ...toArray(globalConfig.envFile),
+        ...toArray(runConfig.envFile),
+        ...(cliOptions.envFile || [])
+    ].filter(Boolean);
+
+    const env = {
+        ...normalizeJsonEnvMap(globalConfig.env, '全局配置'),
+        ...normalizeJsonEnvMap(runConfig.env, '运行配置'),
+        ...normalizeCliEnvMap(cliOptions.env)
+    };
+
+    const firstEnvFile = [
+        ...toArray(globalFirstConfig.envFile),
+        ...toArray(runFirstConfig.envFile),
+        ...(cliOptions.firstEnvFile || [])
+    ].filter(Boolean);
+
+    const firstEnv = {
+        ...normalizeJsonEnvMap(globalFirstConfig.env, '全局配置 first'),
+        ...normalizeJsonEnvMap(runFirstConfig.env, '运行配置 first'),
+        ...normalizeCliEnvMap(cliOptions.firstEnv)
+    };
+
+    const volumes = mergeArrayConfig(globalConfig.volumes, runConfig.volumes, cliOptions.volume)
+        .map(volume => normalizeVolume(volume));
+    const ports = mergeArrayConfig(globalConfig.ports, runConfig.ports, cliOptions.port);
+    const imageBuildArgs = mergeArrayConfig(globalConfig.imageBuildArgs, runConfig.imageBuildArgs, cliOptions.imageBuildArg);
+
+    const yolo = pickConfigValue(cliOptions.yolo, runConfig.yolo, globalConfig.yolo) || '';
+    const containerMode = pickConfigValue(cliOptions.contMode, runConfig.containerMode, globalConfig.containerMode) || '';
+    const quiet = pickConfigValue(cliOptions.quiet, runConfig.quiet, globalConfig.quiet) || [];
+
+    if (cliOptions.shellFull) {
+        execShell = cliOptions.shellFull.join(' ');
+        execPrefix = '';
+        execSuffix = '';
+    }
+
+    if (!cliOptions.shellFull) {
+        const doubleDashIndex = argv.indexOf('--');
+        if (doubleDashIndex !== -1 && doubleDashIndex < argv.length - 1) {
+            execSuffix = normalizeCommandSuffix(argv.slice(doubleDashIndex + 1).join(' '));
+        }
+    }
+
+    let serverHost = null;
+    let serverPort = null;
+    if (isServerMode) {
+        const listen = parseServerListen(cliOptions.server);
+        serverHost = listen.host;
+        serverPort = listen.port;
+    }
+
+    let serverUser = pickConfigValue(cliOptions.serverUser, runConfig.serverUser, globalConfig.serverUser, envVars.MANYOYO_SERVER_USER) || '';
+    let serverPass = pickConfigValue(cliOptions.serverPass, runConfig.serverPass, globalConfig.serverPass, envVars.MANYOYO_SERVER_PASS) || '';
+    let serverPassAuto = false;
+    if (isServerMode && !isServerStopMode) {
+        if (!serverUser) {
+            serverUser = 'admin';
+        }
+        if (!serverPass) {
+            serverPass = crypto.randomBytes(12).toString('hex');
+            serverPassAuto = true;
+        }
+    }
+
+    if (!hostPath) {
+        hostPath = defaults.hostPath;
+    }
+
+    return {
+        hostPath,
+        containerName,
+        containerPath,
+        imageName,
+        imageVersion,
+        envFile,
+        env,
+        firstEnvFile,
+        firstEnv,
+        volumes,
+        ports,
+        imageBuildArgs,
+        containerMode,
+        yolo,
+        quiet,
+        server: isServerMode,
+        serverHost,
+        serverPort,
+        serverUser,
+        serverPass,
+        serverPassAuto,
+        exec: {
+            prefix: execPrefix,
+            shell: execShell,
+            suffix: execSuffix
+        },
+        first: {
+            envFile: firstEnvFile,
+            env: firstEnv,
+            exec: {
+                prefix: firstExecPrefix,
+                shell: firstExecShell,
+                suffix: firstExecSuffix
+            }
+        }
+    };
+}
+
+module.exports = {
+    resolveRuntimeConfig
+};