@xcanwin/manyoyo 5.8.5 → 5.8.9

package/lib/web/container-exec.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const { spawn } = require('child_process');
+
+function createTextBuffer(maxChars) {
+    let value = '';
+    let truncated = false;
+    return {
+        append(chunk) {
+            if (!chunk) {
+                return;
+            }
+            const text = chunk.toString('utf-8');
+            if (!text) {
+                return;
+            }
+            if (value.length >= maxChars) {
+                truncated = true;
+                return;
+            }
+            const remain = maxChars - value.length;
+            if (text.length > remain) {
+                value += text.slice(0, remain);
+                truncated = true;
+                return;
+            }
+            value += text;
+        },
+        buildOutput(suffix) {
+            return truncated ? `${value}\n...${suffix}` : value;
+        }
+    };
+}
+
+function drainLines(text, carry, handleLine) {
+    let pending = carry + String(text || '');
+    let newlineIndex = pending.indexOf('\n');
+    while (newlineIndex !== -1) {
+        const line = pending.slice(0, newlineIndex).replace(/\r$/, '');
+        handleLine(line);
+        pending = pending.slice(newlineIndex + 1);
+        newlineIndex = pending.indexOf('\n');
+    }
+    return pending;
+}
+
+function createWebContainerExecHelpers(options = {}) {
+    const buildWebSessionKey = options.buildWebSessionKey || (() => '');
+    const defaultAgentId = options.defaultAgentId || 'default';
+    const extractAgentMessageFromStructuredOutput = options.extractAgentMessageFromStructuredOutput || (() => '');
+    const parseJsonObjectLine = options.parseJsonObjectLine || (() => null);
+    const prepareStructuredTraceEvents = options.prepareStructuredTraceEvents || (() => []);
+    const extractContentDeltaFromPayload = options.extractContentDeltaFromPayload || (() => null);
+    const structuredTraceDeps = options.structuredTraceDeps || {};
+    const clipText = options.clipText || (text => String(text || ''));
+    const stripAnsi = options.stripAnsi || (text => String(text || ''));
+    const maxRawOutputChars = Number.isInteger(options.maxRawOutputChars) ? options.maxRawOutputChars : 32 * 1024 * 1024;
+
+    function buildFinalOutput(agentProgram, stdoutBuffer, stderrBuffer) {
+        const clippedStdout = stdoutBuffer.buildOutput('[stdout-truncated]');
+        const clippedStderr = stderrBuffer.buildOutput('[stderr-truncated]');
+        const clippedRaw = `${clippedStdout}${clippedStdout && clippedStderr ? '\n' : ''}${clippedStderr}`;
+        const extractedAgentMessage = extractAgentMessageFromStructuredOutput(agentProgram, clippedStdout);
+        const cleanOutputSource = extractedAgentMessage || clippedRaw;
+        return clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
+    }
+
+    return {
+        async execCommandInWebContainer(ctx, containerName, command, options = {}) {
+            const opts = options && typeof options === 'object' ? options : {};
+            const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
+            return await new Promise((resolve, reject) => {
+                const process = spawn(
+                    ctx.dockerCmd,
+                    ['exec', containerName, '/bin/bash', '-lc', command],
+                    { stdio: ['ignore', 'pipe', 'pipe'] }
+                );
+
+                const stdoutBuffer = createTextBuffer(maxRawOutputChars);
+                const stderrBuffer = createTextBuffer(maxRawOutputChars);
+
+                process.stdout.on('data', chunk => stdoutBuffer.append(chunk));
+                process.stderr.on('data', chunk => stderrBuffer.append(chunk));
+
+                process.on('error', reject);
+                process.on('close', code => {
+                    const exitCode = typeof code === 'number' ? code : 1;
+                    resolve({
+                        exitCode,
+                        output: buildFinalOutput(agentProgram, stdoutBuffer, stderrBuffer)
+                    });
+                });
+            });
+        },
+        async execAgentInWebContainerStream(ctx, state, sessionRefOrContainerName, command, options = {}) {
+            const opts = options && typeof options === 'object' ? options : {};
+            const sessionRef = typeof sessionRefOrContainerName === 'string'
+                ? { containerName: sessionRefOrContainerName, agentId: defaultAgentId }
+                : sessionRefOrContainerName;
+            const sessionKey = buildWebSessionKey(sessionRef.containerName, sessionRef.agentId);
+            const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
+            const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : () => {};
+            const process = spawn(
+                ctx.dockerCmd,
+                ['exec', sessionRef.containerName, '/bin/bash', '-lc', command],
+                { stdio: ['ignore', 'pipe', 'pipe'] }
+            );
+
+            const runState = {
+                containerName: sessionRef.containerName,
+                sessionKey,
+                process,
+                command,
+                startedAt: new Date().toISOString(),
+                stopping: false
+            };
+            state.agentRuns.set(sessionRef.containerName, runState);
+
+            return await new Promise((resolve, reject) => {
+                const stdoutBuffer = createTextBuffer(maxRawOutputChars);
+                const stderrBuffer = createTextBuffer(maxRawOutputChars);
+                let stdoutPending = '';
+                let stderrPending = '';
+                const structuredTraceState = {
+                    toolNamesById: new Map()
+                };
+                let contentDeltaAccumulator = '';
+
+                function emitStdoutTraceLine(line) {
+                    const rawLine = String(line || '').trim();
+                    if (!rawLine) {
+                        return;
+                    }
+                    if (agentProgram === 'claude' || agentProgram === 'gemini' || agentProgram === 'codex' || agentProgram === 'opencode') {
+                        const payload = parseJsonObjectLine(rawLine);
+                        if (payload) {
+                            const traceEvents = prepareStructuredTraceEvents(agentProgram, payload, structuredTraceState, structuredTraceDeps);
+                            traceEvents.forEach(traceEvent => {
+                                if (!traceEvent || !traceEvent.text) {
+                                    return;
+                                }
+                                onEvent({
+                                    type: 'trace',
+                                    stream: 'stdout',
+                                    text: traceEvent.text,
+                                    traceEvent
+                                });
+                            });
+                            const deltaContent = extractContentDeltaFromPayload(agentProgram, payload, structuredTraceDeps);
+                            if (deltaContent !== null) {
+                                if (deltaContent.reset) {
+                                    contentDeltaAccumulator = deltaContent.text;
+                                } else {
+                                    contentDeltaAccumulator += deltaContent.text;
+                                }
+                                onEvent({
+                                    type: 'content_delta',
+                                    content: contentDeltaAccumulator
+                                });
+                            }
+                            return;
+                        }
+                        if (agentProgram === 'codex' && (/^OpenAI Codex\b/.test(rawLine) || /^tokens used\b/i.test(rawLine))) {
+                            return;
+                        }
+                    }
+                    onEvent({ type: 'trace', stream: 'stdout', text: rawLine });
+                }
+
+                function emitStderrTraceLine(line) {
+                    const rawLine = String(line || '').trim();
+                    if (!rawLine) {
+                        return;
+                    }
+                    onEvent({ type: 'trace', stream: 'stderr', text: `[stderr] ${rawLine}` });
+                }
+
+                process.stdout.on('data', chunk => {
+                    stdoutBuffer.append(chunk);
+                    stdoutPending = drainLines(chunk.toString('utf-8'), stdoutPending, emitStdoutTraceLine);
+                });
+                process.stderr.on('data', chunk => {
+                    stderrBuffer.append(chunk);
+                    stderrPending = drainLines(chunk.toString('utf-8'), stderrPending, emitStderrTraceLine);
+                });
+
+                process.on('error', error => {
+                    state.agentRuns.delete(sessionRef.containerName);
+                    reject(error);
+                });
+                process.on('close', code => {
+                    state.agentRuns.delete(sessionRef.containerName);
+                    if (stdoutPending) {
+                        emitStdoutTraceLine(stdoutPending);
+                        stdoutPending = '';
+                    }
+                    if (stderrPending) {
+                        emitStderrTraceLine(stderrPending);
+                        stderrPending = '';
+                    }
+                    const exitCode = typeof code === 'number' ? code : 1;
+                    resolve({
+                        exitCode,
+                        output: buildFinalOutput(agentProgram, stdoutBuffer, stderrBuffer),
+                        interrupted: exitCode !== 0 && runState.stopping === true
+                    });
+                });
+            });
+        }
+    };
+}
+
+module.exports = {
+    createWebContainerExecHelpers
+};

package/lib/web/http-handlers.js

@@ -0,0 +1,163 @@
+'use strict';
+
+function createWebHttpHandlers(deps) {
+    const {
+        loadTemplate,
+        sendHtml,
+        sendJson,
+        sendRedirect,
+        sendStaticAsset,
+        sendVendorAsset,
+        readJsonBody,
+        secureStringEqual,
+        createWebAuthSession,
+        clearWebAuthSession,
+        getWebAuthCookie,
+        getWebAuthClearCookie,
+        getWebAuthSession,
+        AUTH_FRONTEND_ASSETS,
+        APP_FRONTEND_ASSETS,
+        APP_VENDOR_ASSETS,
+        handleWebApi
+    } = deps;
+
+    function serveAllowedStaticAsset(req, res, pathname, pattern, allowedAssets, sendAsset) {
+        const matched = req.method === 'GET' ? pathname.match(pattern) : null;
+        if (!matched) {
+            return false;
+        }
+        const assetName = matched[1];
+        if (!allowedAssets.has(assetName)) {
+            sendHtml(res, 404, '<h1>404 Not Found</h1>');
+            return true;
+        }
+        sendAsset(res, assetName);
+        return true;
+    }
+
+    async function handleWebAuthRoutes(req, res, pathname, ctx, state) {
+        if (req.method === 'GET' && pathname === '/favicon.ico') {
+            res.writeHead(204, { 'Cache-Control': 'no-store' });
+            res.end();
+            return true;
+        }
+
+        if (req.method === 'GET' && pathname === '/auth/login') {
+            sendHtml(res, 200, loadTemplate('login.html'));
+            return true;
+        }
+
+        if (serveAllowedStaticAsset(req, res, pathname, /^\/auth\/frontend\/([A-Za-z0-9._-]+)$/, AUTH_FRONTEND_ASSETS, sendStaticAsset)) {
+            return true;
+        }
+
+        if (req.method === 'POST' && pathname === '/auth/login') {
+            const payload = await readJsonBody(req);
+            const username = String(payload.username || '').trim();
+            const password = String(payload.password || '');
+
+            if (!username || !password) {
+                sendJson(res, 400, { error: '用户名和密码不能为空' });
+                return true;
+            }
+
+            const userOk = secureStringEqual(username, ctx.authUser);
+            const passOk = secureStringEqual(password, ctx.authPass);
+            if (!(userOk && passOk)) {
+                sendJson(res, 401, { error: '用户名或密码错误' });
+                return true;
+            }
+
+            const sessionId = createWebAuthSession(state, username);
+            sendJson(
+                res,
+                200,
+                { ok: true, username },
+                { 'Set-Cookie': getWebAuthCookie(sessionId) }
+            );
+            return true;
+        }
+
+        if (req.method === 'POST' && pathname === '/auth/logout') {
+            clearWebAuthSession(state, req);
+            sendJson(
+                res,
+                200,
+                { ok: true },
+                { 'Set-Cookie': getWebAuthClearCookie() }
+            );
+            return true;
+        }
+
+        return false;
+    }
+
+    function sendWebUnauthorized(res, pathname) {
+        if (pathname.startsWith('/api/') || pathname.startsWith('/auth/')) {
+            sendJson(res, 401, { error: 'UNAUTHORIZED' });
+            return;
+        }
+        if (pathname === '/' || pathname === '') {
+            sendRedirect(res, 302, '/auth/login', { 'Set-Cookie': getWebAuthClearCookie() });
+            return;
+        }
+        sendHtml(
+            res,
+            401,
+            loadTemplate('login.html'),
+            { 'Set-Cookie': getWebAuthClearCookie() }
+        );
+    }
+
+    async function handleWebHttpRequest(req, res, pathname, ctx, state) {
+        if (await handleWebAuthRoutes(req, res, pathname, ctx, state)) {
+            return true;
+        }
+
+        const authSession = getWebAuthSession(state, req);
+        if (!authSession) {
+            sendWebUnauthorized(res, pathname);
+            return true;
+        }
+
+        if (req.method === 'GET' && pathname === '/') {
+            sendHtml(res, 200, loadTemplate('app.html'));
+            return true;
+        }
+
+        if (serveAllowedStaticAsset(req, res, pathname, /^\/app\/frontend\/([A-Za-z0-9._-]+)$/, APP_FRONTEND_ASSETS, sendStaticAsset)) {
+            return true;
+        }
+
+        if (serveAllowedStaticAsset(req, res, pathname, /^\/app\/vendor\/([A-Za-z0-9._-]+)$/, APP_VENDOR_ASSETS, sendVendorAsset)) {
+            return true;
+        }
+
+        if (pathname === '/healthz') {
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+
+        if (pathname.startsWith('/api/')) {
+            const handled = await handleWebApi(req, res, pathname, ctx, state);
+            if (!handled) {
+                sendJson(res, 404, { error: 'Not Found' });
+            }
+            return true;
+        }
+
+        sendHtml(res, 404, '<h1>404 Not Found</h1>');
+        return true;
+    }
+
+    return {
+        serveAllowedStaticAsset,
+        handleWebAuthRoutes,
+        sendWebUnauthorized,
+        handleWebHttpRequest
+    };
+}
+
+module.exports = {
+    createWebHttpHandlers
+};

package/lib/web/runtime-state.js

@@ -0,0 +1,50 @@
+'use strict';
+
+function createWebRuntimeStateHelpers(options = {}) {
+    const createMap = () => new Map();
+
+    return {
+        createInitialWebRuntimeState(baseState = {}) {
+            return {
+                ...baseState,
+                authSessions: createMap(),
+                terminalSessions: createMap(),
+                agentRuns: createMap()
+            };
+        },
+        stopWebAgentRun(state, containerName) {
+            const runState = state.agentRuns.get(containerName);
+            if (!runState || !runState.process || runState.process.killed) {
+                return false;
+            }
+            runState.stopping = true;
+            try {
+                runState.process.kill('SIGTERM');
+            } catch {
+                return false;
+            }
+            return true;
+        },
+        cleanupWebRuntimeState(state) {
+            for (const session of state.terminalSessions.values()) {
+                const ptyProcess = session && session.ptyProcess;
+                if (ptyProcess && !ptyProcess.killed) {
+                    try { ptyProcess.kill('SIGTERM'); } catch {}
+                }
+            }
+            state.terminalSessions.clear();
+
+            for (const runState of state.agentRuns.values()) {
+                const child = runState && runState.process;
+                if (child && !child.killed) {
+                    try { child.kill('SIGTERM'); } catch {}
+                }
+            }
+            state.agentRuns.clear();
+        }
+    };
+}
+
+module.exports = {
+    createWebRuntimeStateHelpers
+};

package/lib/web/server-context.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+function createWebServerContextHelpers(options = {}) {
+    const createInitialWebRuntimeState = options.createInitialWebRuntimeState || (base => base);
+    const getDefaultWebConfigPath = options.getDefaultWebConfigPath || (() => '');
+
+    return {
+        createWebServerContext(rawOptions = {}) {
+            const fallbackLogger = {
+                info: () => {},
+                warn: () => {},
+                error: () => {}
+            };
+            const ctx = {
+                serverHost: rawOptions.serverHost || '127.0.0.1',
+                serverPort: rawOptions.serverPort,
+                authUser: rawOptions.authUser,
+                authPass: rawOptions.authPass,
+                authPassAuto: rawOptions.authPassAuto,
+                dockerCmd: rawOptions.dockerCmd,
+                hostPath: rawOptions.hostPath,
+                containerPath: rawOptions.containerPath,
+                imageName: rawOptions.imageName,
+                imageVersion: rawOptions.imageVersion,
+                execCommandPrefix: rawOptions.execCommandPrefix,
+                execCommand: rawOptions.execCommand,
+                execCommandSuffix: rawOptions.execCommandSuffix,
+                contModeArgs: rawOptions.contModeArgs,
+                containerExtraArgs: rawOptions.containerExtraArgs,
+                containerEnvs: rawOptions.containerEnvs,
+                containerVolumes: rawOptions.containerVolumes,
+                containerPorts: rawOptions.containerPorts,
+                validateHostPath: rawOptions.validateHostPath,
+                formatDate: rawOptions.formatDate,
+                isValidContainerName: rawOptions.isValidContainerName,
+                containerExists: rawOptions.containerExists,
+                getContainerStatus: rawOptions.getContainerStatus,
+                waitForContainerReady: rawOptions.waitForContainerReady,
+                dockerExecArgs: rawOptions.dockerExecArgs,
+                showImagePullHint: rawOptions.showImagePullHint,
+                removeContainer: rawOptions.removeContainer,
+                logger: rawOptions.logger && typeof rawOptions.logger.info === 'function' ? rawOptions.logger : fallbackLogger,
+                colors: rawOptions.colors || {
+                    GREEN: '',
+                    CYAN: '',
+                    YELLOW: '',
+                    NC: ''
+                }
+            };
+
+            if (!ctx.authUser || !ctx.authPass) {
+                throw new Error('Web 认证配置缺失，请设置 serve -U / serve -P');
+            }
+
+            return ctx;
+        },
+        createWebServerState(rawOptions = {}) {
+            return createInitialWebRuntimeState({
+                webHistoryDir: rawOptions.webHistoryDir || path.join(os.homedir(), '.manyoyo', 'web-history'),
+                webConfigPath: rawOptions.webConfigPath || getDefaultWebConfigPath()
+            });
+        }
+    };
+}
+
+module.exports = {
+    createWebServerContextHelpers
+};

package/lib/web/server-lifecycle.js

@@ -0,0 +1,129 @@
+'use strict';
+
+function createWebServerLifecycleHelpers(options = {}) {
+    const http = options.http;
+    const WebSocket = options.WebSocket;
+    const formatUrlHost = options.formatUrlHost || (host => host);
+    const normalizeTerminalSize = options.normalizeTerminalSize || ((cols, rows) => ({ cols, rows }));
+    const bindTerminalWebSocket = options.bindTerminalWebSocket || (() => {});
+    const handleWebUpgradeRequest = options.handleWebUpgradeRequest || (() => {});
+    const sendJson = options.sendJson || (() => {});
+    const sendHtml = options.sendHtml || (() => {});
+    const cleanupWebRuntimeState = options.cleanupWebRuntimeState || (() => {});
+
+    return {
+        createWsServer(ctx, state) {
+            const wsServer = new WebSocket.Server({
+                noServer: true,
+                maxPayload: 1024 * 1024
+            });
+            wsServer.on('error', err => {
+                ctx.logger.error('ws server error', err);
+            });
+
+            wsServer.on('connection', (ws, req, meta = {}) => {
+                const containerName = meta.containerName;
+                if (!containerName || !ctx.isValidContainerName(containerName)) {
+                    ws.close();
+                    return;
+                }
+                const { cols, rows } = normalizeTerminalSize(meta.cols, meta.rows);
+                bindTerminalWebSocket(ctx, state, ws, containerName, cols, rows);
+            });
+
+            return wsServer;
+        },
+        createHttpServer(ctx, state, wsServer, handleWebHttpRequest) {
+            const server = http.createServer(async (req, res) => {
+                try {
+                    const fallbackHost = `${formatUrlHost(ctx.serverHost)}:${ctx.serverPort}`;
+                    const url = new URL(req.url, `http://${req.headers.host || fallbackHost}`);
+                    const pathname = url.pathname;
+                    await handleWebHttpRequest(req, res, pathname, ctx, state);
+                } catch (error) {
+                    ctx.logger.error('http request error', {
+                        method: req && req.method ? req.method : '',
+                        url: req && req.url ? req.url : '',
+                        message: error && error.message ? error.message : 'Server Error'
+                    });
+                    if ((req.url || '').startsWith('/api/')) {
+                        sendJson(res, 500, { error: error.message || 'Server Error' });
+                    } else {
+                        sendHtml(res, 500, '<h1>500 Server Error</h1>');
+                    }
+                }
+            });
+            server.on('error', err => {
+                ctx.logger.error('http server error', err);
+            });
+            server.on('close', () => {
+                ctx.logger.warn('http server closed');
+            });
+            server.on('upgrade', (req, socket, head) => {
+                handleWebUpgradeRequest(req, socket, head, wsServer, ctx, state, server.__manyoyoListenPort || ctx.serverPort);
+            });
+            return server;
+        },
+        async listenWebServer(server, ctx) {
+            let listenPort = ctx.serverPort;
+            await new Promise((resolve, reject) => {
+                server.once('error', err => {
+                    ctx.logger.error('http server listen failed', err);
+                    reject(err);
+                });
+                server.listen(ctx.serverPort, ctx.serverHost, () => {
+                    const address = server.address();
+                    if (address && typeof address === 'object' && typeof address.port === 'number') {
+                        listenPort = address.port;
+                    }
+                    server.__manyoyoListenPort = listenPort;
+                    const { GREEN, CYAN, YELLOW, NC } = ctx.colors;
+                    const listenHost = formatUrlHost(ctx.serverHost);
+                    console.log(`${GREEN}✅ MANYOYO Web 服务已启动: http://${listenHost}:${listenPort}${NC}`);
+                    console.log(`${CYAN}提示: 左侧是 manyoyo 容器会话列表，中间是活动/终端/配置/检查工作台，右侧显示当前会话上下文。${NC}`);
+                    if (ctx.serverHost === '0.0.0.0') {
+                        console.log(`${CYAN}提示: 当前监听全部网卡，请用本机局域网 IP 访问。${NC}`);
+                    }
+                    console.log(`${CYAN}🔐 登录用户名: ${YELLOW}${ctx.authUser}${NC}`);
+                    if (ctx.authPassAuto) {
+                        console.log(`${CYAN}🔐 登录密码(本次随机): ${YELLOW}${ctx.authPass}${NC}`);
+                    } else {
+                        console.log(`${CYAN}🔐 登录密码: 使用你配置的 serve -P / serverPass / MANYOYO_SERVER_PASS${NC}`);
+                    }
+                    ctx.logger.info('web server started', {
+                        host: ctx.serverHost,
+                        port: listenPort,
+                        authUser: ctx.authUser,
+                        authPassAuto: Boolean(ctx.authPassAuto)
+                    });
+                    resolve();
+                });
+            });
+            return listenPort;
+        },
+        closeWebServer(server, wsServer, ctx, state) {
+            return new Promise(resolve => {
+                ctx.logger.info('web server closing');
+                cleanupWebRuntimeState(state);
+
+                const closeHttp = () => {
+                    if (!server.listening) {
+                        resolve();
+                        return;
+                    }
+                    server.close(() => resolve());
+                };
+
+                try {
+                    wsServer.close(() => closeHttp());
+                } catch {
+                    closeHttp();
+                }
+            });
+        }
+    };
+}
+
+module.exports = {
+    createWebServerLifecycleHelpers
+};