@xcanwin/manyoyo 5.8.6 → 5.8.9

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
+};

package/lib/web/agent-command.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const {
+    resolveAgentProgram,
+    buildAgentResumeCommand
+} = require('../agent-resume');
+
+function normalizeAgentPromptCommandTemplate(value, sourceLabel = 'agentPromptCommand') {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${sourceLabel} 必须是字符串`);
+    }
+    const text = value.trim();
+    if (!text) {
+        return '';
+    }
+    if (!text.includes('{prompt}')) {
+        throw new Error(`${sourceLabel} 必须包含 {prompt} 占位符`);
+    }
+    if (/^codex\s+exec(?:\s|$)/.test(text) && !text.includes('--skip-git-repo-check')) {
+        return text.replace(/^codex\s+exec\b/, 'codex exec --skip-git-repo-check');
+    }
+    return text;
+}
+
+function isAgentPromptCommandEnabled(value) {
+    return typeof value === 'string' && value.includes('{prompt}') && Boolean(value.trim());
+}
+
+function quoteBashSingleValue(value) {
+    const text = String(value || '');
+    return `'${text.replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function renderAgentPromptCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const safePrompt = quoteBashSingleValue(prompt);
+    return templateText.replace(/\{prompt\}/g, safePrompt);
+}
+
+function prependAgentFlags(commandText, matchPattern, flagSpecs) {
+    const matched = String(commandText || '').match(matchPattern);
+    if (!matched) {
+        return String(commandText || '');
+    }
+    const prefix = matched[1] || '';
+    let suffix = matched[matched.length - 1] || '';
+    for (let i = flagSpecs.length - 1; i >= 0; i -= 1) {
+        const spec = flagSpecs[i];
+        if (!spec || !spec.flag || !(spec.pattern instanceof RegExp) || spec.pattern.test(suffix)) {
+            continue;
+        }
+        suffix = ` ${spec.flag}${suffix}`;
+    }
+    return `${prefix}${suffix}`;
+}
+
+function buildCodexAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const execMatch = templateText.match(
+        /^((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)codex\s+exec\b/
+    );
+    let codexTemplate = templateText;
+    if (execMatch) {
+        const prefix = execMatch[1] || '';
+        const suffix = templateText.slice(execMatch[0].length);
+        const hasJson = /(?:^|\s)--json(?:\s|$)/.test(suffix);
+        const injectedFlags = hasJson ? '' : ' --json';
+        codexTemplate = `${prefix}codex exec${injectedFlags}${suffix}`;
+    }
+    return codexTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(codexTemplate, prompt);
+}
+
+function buildClaudeAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const claudeTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)claude\b)(.*)$/,
+        [
+            { flag: '--verbose', pattern: /(?:^|\s)--verbose(?:\s|$)/ },
+            { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ }
+        ]
+    );
+    return claudeTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(claudeTemplate, prompt);
+}
+
+function buildGeminiAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const geminiTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)gemini\b)(.*)$/,
+        [
+            { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ }
+        ]
+    );
+    return geminiTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(geminiTemplate, prompt);
+}
+
+function buildOpenCodeAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const opencodeTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)opencode\s+run\b)(.*)$/,
+        [
+            { flag: '--format json', pattern: /(?:^|\s)--format(?:\s|$)/ }
+        ]
+    );
+    return opencodeTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(opencodeTemplate, prompt);
+}
+
+function buildWebAgentExecCommand(template, prompt, agentProgram) {
+    switch (agentProgram) {
+    case 'claude':
+        return buildClaudeAgentExecCommand(template, prompt);
+    case 'gemini':
+        return buildGeminiAgentExecCommand(template, prompt);
+    case 'codex':
+        return buildCodexAgentExecCommand(template, prompt);
+    case 'opencode':
+        return buildOpenCodeAgentExecCommand(template, prompt);
+    default:
+        break;
+    }
+    return renderAgentPromptCommand(template, prompt);
+}
+
+function getAgentRuntimeMeta(template) {
+    const normalizedTemplate = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const agentProgram = resolveAgentProgram(normalizedTemplate);
+    const resumeCommand = buildAgentResumeCommand(agentProgram);
+    return {
+        agentProgram: agentProgram || '',
+        resumeCommand: resumeCommand || '',
+        resumeSupported: Boolean(resumeCommand)
+    };
+}
+
+module.exports = {
+    normalizeAgentPromptCommandTemplate,
+    isAgentPromptCommandEnabled,
+    buildWebAgentExecCommand,
+    getAgentRuntimeMeta
+};

package/lib/web/api-route-helpers.js

@@ -0,0 +1,88 @@
+'use strict';
+
+function createApiRouteHelpers(deps) {
+    const {
+        req,
+        res,
+        ctx,
+        state,
+        sendJson,
+        readJsonBody,
+        getValidSessionRef,
+        prepareWebAgentExecution
+    } = deps;
+
+    const withSessionRef = handler => async match => {
+        const sessionRef = getValidSessionRef(ctx, res, match[1]);
+        if (!sessionRef) {
+            return;
+        }
+        await handler(sessionRef, match);
+    };
+
+    const withJsonBody = handler => async (...args) => {
+        const payload = await readJsonBody(req);
+        await handler(payload, ...args);
+    };
+
+    const withSessionJsonBody = (handler, fallbackError = '') => withSessionRef(async (sessionRef, match) => {
+        let payload = null;
+        if (fallbackError) {
+            try {
+                payload = await readJsonBody(req);
+            } catch (e) {
+                sendJson(res, 400, { error: e.message || fallbackError });
+                return;
+            }
+        } else {
+            payload = await readJsonBody(req);
+        }
+        await handler(sessionRef, payload, match);
+    });
+
+    const getRequiredBodyText = (payload, key, emptyMessage) => {
+        const value = String(payload && payload[key] || '').trim();
+        if (!value) {
+            sendJson(res, 400, { error: emptyMessage });
+            return null;
+        }
+        return value;
+    };
+
+    const prepareAgentRequest = async (sessionRef, prompt) => {
+        try {
+            return await prepareWebAgentExecution(ctx, state, sessionRef, prompt);
+        } catch (e) {
+            sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
+            return null;
+        }
+    };
+
+    return {
+        withSessionRef,
+        withJsonBody,
+        withSessionJsonBody,
+        getRequiredBodyText,
+        prepareAgentRequest
+    };
+}
+
+async function runMatchedRoute(routes, method, pathname) {
+    for (const route of routes) {
+        if (route.method !== method) {
+            continue;
+        }
+        const matched = route.match(pathname);
+        if (!matched) {
+            continue;
+        }
+        await route.handler(matched);
+        return true;
+    }
+    return false;
+}
+
+module.exports = {
+    createApiRouteHelpers,
+    runMatchedRoute
+};