@xcanwin/manyoyo 5.6.8 → 5.6.9

package/lib/agent-resume.js

@@ -16,6 +16,8 @@ const AGENT_PROMPT_TEMPLATE_MAP = {
     opencode: 'opencode run {prompt}'
 };
 
+const CODEX_DANGEROUS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
+
 function stripLeadingAssignments(commandText) {
     let rest = String(commandText || '').trim();
     const assignmentPattern = /^(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)(?:\s+|$)/;
@@ -75,8 +77,15 @@ function resolveAgentResumeArg(commandText) {
 }
 
 function resolveAgentPromptCommandTemplate(commandText) {
+    const normalizedCommand = String(commandText || '').trim();
     const program = resolveAgentProgram(commandText);
-    return AGENT_PROMPT_TEMPLATE_MAP[program] || '';
+    const template = AGENT_PROMPT_TEMPLATE_MAP[program] || '';
+    if (program === 'codex' && template) {
+        if (normalizedCommand.includes(CODEX_DANGEROUS_FLAG)) {
+            return `codex exec ${CODEX_DANGEROUS_FLAG} --skip-git-repo-check {prompt}`;
+        }
+    }
+    return template;
 }
 
 function buildAgentResumeCommand(commandText) {

package/lib/web/frontend/app.css

@@ -1079,6 +1079,12 @@ body.command-mode .msg.origin-agent .bubble {
     gap: 10px;
 }
 
+.composer-actions {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
 #commandInput {
     width: 100%;
     min-height: 116px;
@@ -1098,6 +1104,10 @@ body.command-mode .msg.origin-agent .bubble {
     min-width: 92px;
 }
 
+#stopBtn {
+    min-width: 92px;
+}
+
 .composer-foot {
     margin-top: 8px;
     display: flex;

package/lib/web/frontend/app.html

@@ -108,7 +108,10 @@
                         </div>
                         <div class="composer-inner">
                             <textarea id="commandInput" placeholder="输入容器命令，例如: ls -la"></textarea>
-                            <button type="submit" id="sendBtn">发送</button>
+                            <div class="composer-actions">
+                                <button type="submit" id="sendBtn">发送</button>
+                                <button type="button" id="stopBtn" class="danger-outline">停止</button>
+                            </div>
                         </div>
                         <div class="composer-foot">
                             <span id="composerHint">Enter 发送 · Shift/Alt + Enter 换行</span>

package/lib/web/frontend/app.js

@@ -64,6 +64,13 @@
         sessionNodeMap: new Map(),
         sessionRenderMode: 'empty',
         messageRequestId: 0,
+        agentRun: {
+            active: false,
+            sessionName: '',
+            stopping: false,
+            controller: null,
+            traceMessageId: ''
+        },
         terminal: {
             term: null,
             fitAddon: null,
@@ -142,6 +149,7 @@
     const composerHint = document.getElementById('composerHint');
     const sendState = document.getElementById('sendState');
     const sendBtn = document.getElementById('sendBtn');
+    const stopBtn = document.getElementById('stopBtn');
     const refreshBtn = document.getElementById('refreshBtn');
     const removeBtn = document.getElementById('removeBtn');
     const removeAllBtn = document.getElementById('removeAllBtn');
@@ -185,6 +193,9 @@
     function roleName(role, message) {
         if (role === 'user') return '我';
         if (role === 'assistant') {
+            if (message && message.streamTrace) {
+                return 'AGENT 过程';
+            }
             if (message && message.mode === 'agent') {
                 return 'AGENT 回复';
             }
@@ -357,7 +368,11 @@
 
     function resolveAgentPromptTemplate(commandText) {
         const program = resolveAgentProgram(commandText);
-        return AGENT_PROMPT_TEMPLATE_MAP[program] || '';
+        const template = AGENT_PROMPT_TEMPLATE_MAP[program] || '';
+        if (program === 'codex' && String(commandText || '').includes('--dangerously-bypass-approvals-and-sandbox')) {
+            return 'codex exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check {prompt}';
+        }
+        return template;
     }
 
     function inferCreateAgentPromptCommand() {
@@ -541,6 +556,15 @@
         }) || null;
     }
 
+    function isAgentRunActiveForSession(sessionName) {
+        return Boolean(
+            state.agentRun
+            && state.agentRun.active
+            && state.agentRun.sessionName
+            && state.agentRun.sessionName === String(sessionName || '').trim()
+        );
+    }
+
     function isActiveSessionHistoryOnly() {
         const session = getActiveSession();
         return sessionStatusInfo(session && session.status).tone === 'history';
@@ -1187,11 +1211,15 @@
             scheduleTerminalFit(false);
         }
 
+        const activeAgentRunning = isAgentRunActiveForSession(state.active);
         const busy = state.loadingSessions || state.loadingMessages || state.sending;
         refreshBtn.disabled = busy;
         removeBtn.disabled = !state.active || busy;
         removeAllBtn.disabled = !state.active || busy;
         sendBtn.disabled = !activityTab || !state.active || busy || (agentMode && !agentEnabled);
+        if (stopBtn) {
+            stopBtn.disabled = !activityTab || !agentMode || !activeAgentRunning || state.agentRun.stopping;
+        }
         commandInput.disabled = !activityTab || !state.active || (agentMode && !agentEnabled);
         if (commandInput) {
             commandInput.placeholder = agentMode
@@ -1200,7 +1228,7 @@
         }
         if (composerHint) {
             composerHint.textContent = agentMode
-                ? 'Enter 发送提示词 · Shift/Alt + Enter 换行'
+                ? 'Enter 发送提示词 · Shift/Alt + Enter 换行 · 执行中可停止'
                 : 'Enter 发送 · Shift/Alt + Enter 换行';
         }
         if (openCreateBtn) {
@@ -1227,6 +1255,21 @@
         if (createCancelBtn) {
             createCancelBtn.disabled = state.createSubmitting;
         }
+        if (sendState) {
+            if (!state.active) {
+                sendState.textContent = '未选择会话';
+                sendState.classList.remove('is-active');
+            } else if (activeAgentRunning && agentMode) {
+                sendState.textContent = state.agentRun.stopping ? '正在停止 Agent…' : 'Agent 执行中';
+                sendState.classList.add('is-active');
+            } else if (busy) {
+                sendState.textContent = '处理中';
+                sendState.classList.add('is-active');
+            } else {
+                sendState.textContent = agentMode ? 'Agent 就绪' : '命令就绪';
+                sendState.classList.remove('is-active');
+            }
+        }
         if (configModal) {
             configModal.hidden = !state.configModalOpen;
         }
@@ -1276,6 +1319,80 @@
         return data;
     }
 
+    async function apiStream(url, options, handlers) {
+        const requestOptions = Object.assign(
+            { headers: { 'Content-Type': 'application/json', 'X-Requested-With': 'XMLHttpRequest' } },
+            options || {}
+        );
+        const streamHandlers = handlers && typeof handlers === 'object' ? handlers : {};
+        const response = await fetch(url, requestOptions);
+        if (response.status === 401) {
+            window.location.href = '/';
+            throw new Error('未登录或登录已过期');
+        }
+        if (!response.ok) {
+            let errorText = '请求失败';
+            try {
+                const data = await response.json();
+                errorText = data && data.detail ? `${data.error || '请求失败'}: ${data.detail}` : (data.error || '请求失败');
+            } catch (e) {
+                errorText = '请求失败';
+            }
+            throw new Error(errorText);
+        }
+        if (!response.body || typeof response.body.getReader !== 'function') {
+            throw new Error('当前浏览器不支持流式读取');
+        }
+
+        const decoder = new window.TextDecoder();
+        const reader = response.body.getReader();
+        let pending = '';
+
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                break;
+            }
+            pending += decoder.decode(result.value, { stream: true });
+            const lines = pending.split('\n');
+            pending = lines.pop() || '';
+            lines.forEach(function (line) {
+                const text = String(line || '').trim();
+                if (!text) {
+                    return;
+                }
+                let payload = null;
+                try {
+                    payload = JSON.parse(text);
+                } catch (e) {
+                    payload = null;
+                }
+                if (!payload) {
+                    return;
+                }
+                if (typeof streamHandlers.onEvent === 'function') {
+                    streamHandlers.onEvent(payload);
+                }
+            });
+        }
+
+        const rest = decoder.decode();
+        if (rest) {
+            pending += rest;
+        }
+        const finalText = String(pending || '').trim();
+        if (finalText) {
+            try {
+                const payload = JSON.parse(finalText);
+                if (typeof streamHandlers.onEvent === 'function') {
+                    streamHandlers.onEvent(payload);
+                }
+            } catch (e) {
+                // ignore trailing non-json fragments
+            }
+        }
+    }
+
     async function fetchConfigSnapshot() {
         const snapshot = await api('/api/config');
         state.configSnapshot = snapshot;
@@ -1595,6 +1712,11 @@
     }
 
     function getMessageRenderKey(msg, index) {
+        if (msg && msg.id && msg.streamTrace) {
+            const content = msg.content ? String(msg.content) : '';
+            const timestamp = msg.timestamp ? String(msg.timestamp) : '';
+            return `id:${msg.id}|trace|${timestamp}|${content}`;
+        }
         if (msg && msg.id) {
             return `id:${msg.id}`;
         }
@@ -1641,7 +1763,7 @@
         const bubble = document.createElement('div');
         bubble.className = 'bubble';
 
-        const shouldRenderMarkdown = Boolean(markdownRenderer && markdownRenderer.shouldRenderMessage(msg));
+        const shouldRenderMarkdown = Boolean(!msg.streamTrace && markdownRenderer && markdownRenderer.shouldRenderMessage(msg));
         if (shouldRenderMarkdown) {
             const markdownNode = document.createElement('div');
             markdownNode.className = 'md-content';
@@ -1941,6 +2063,46 @@
         return -1;
     }
 
+    function appendAgentTraceMessageLocal(sessionName) {
+        const traceMessage = {
+            id: createLocalMessageId('local-agent-trace'),
+            role: 'assistant',
+            content: '[执行过程]\n等待 Agent 启动…',
+            timestamp: new Date().toISOString(),
+            mode: 'agent',
+            streamTrace: true
+        };
+        if (state.active === sessionName) {
+            state.messages.push(traceMessage);
+        }
+        return traceMessage.id;
+    }
+
+    function updateAgentTraceMessageLocal(sessionName, traceMessageId, content) {
+        if (state.active !== sessionName) {
+            return;
+        }
+        for (let i = state.messages.length - 1; i >= 0; i -= 1) {
+            const message = state.messages[i];
+            if (!message || String(message.id || '') !== String(traceMessageId || '')) {
+                continue;
+            }
+            message.content = String(content || '');
+            message.timestamp = new Date().toISOString();
+            return;
+        }
+    }
+
+    function finalizeAgentRunState() {
+        if (state.agentRun && state.agentRun.controller) {
+            state.agentRun.controller = null;
+        }
+        state.agentRun.active = false;
+        state.agentRun.stopping = false;
+        state.agentRun.sessionName = '';
+        state.agentRun.traceMessageId = '';
+    }
+
     function appendAssistantMessageLocal(sessionName, result, mode) {
         if (state.active !== sessionName) {
             return;
@@ -1957,6 +2119,109 @@
         });
     }
 
+    async function sendAgentPromptStream(sessionName, inputText, pendingMessage) {
+        const traceMessageId = appendAgentTraceMessageLocal(sessionName);
+        const traceLines = ['[执行过程]', '等待 Agent 启动…'];
+        let finalResult = null;
+        let streamError = null;
+
+        state.agentRun.active = true;
+        state.agentRun.sessionName = sessionName;
+        state.agentRun.stopping = false;
+        state.agentRun.controller = new window.AbortController();
+        state.agentRun.traceMessageId = traceMessageId;
+        renderMessages(state.messages, { stickToBottom: true });
+        syncUi();
+
+        function pushTraceLine(text) {
+            const line = String(text || '').trim();
+            if (!line) {
+                return;
+            }
+            if (traceLines[traceLines.length - 1] === line) {
+                return;
+            }
+            traceLines.push(line);
+            updateAgentTraceMessageLocal(sessionName, traceMessageId, traceLines.join('\n'));
+            if (state.active === sessionName) {
+                renderMessages(state.messages, { stickToBottom: true });
+            }
+        }
+
+        try {
+            await apiStream('/api/sessions/' + encodeURIComponent(sessionName) + '/agent/stream', {
+                method: 'POST',
+                body: JSON.stringify({ prompt: inputText }),
+                signal: state.agentRun.controller.signal
+            }, {
+                onEvent: function (event) {
+                    if (!event || typeof event !== 'object') {
+                        return;
+                    }
+                    if (event.type === 'meta') {
+                        const contextMode = String(event.contextMode || '').trim();
+                        const modeLabel = contextMode ? '上下文模式: ' + contextMode : '';
+                        if (modeLabel) {
+                            pushTraceLine(modeLabel);
+                        }
+                        if (event.resumeAttempted) {
+                            pushTraceLine(event.resumeSucceeded ? '会话恢复成功' : '会话恢复失败，已回退到历史注入');
+                        }
+                        return;
+                    }
+                    if (event.type === 'trace') {
+                        pushTraceLine(event.text || '');
+                        return;
+                    }
+                    if (event.type === 'result') {
+                        finalResult = event;
+                        if (event.interrupted) {
+                            pushTraceLine('[任务] 已停止');
+                        } else {
+                            pushTraceLine('[任务] 已完成');
+                        }
+                        return;
+                    }
+                    if (event.type === 'error') {
+                        streamError = new Error(event.error || 'Agent 执行失败');
+                    }
+                }
+            });
+        } catch (e) {
+            if (!(e && e.name === 'AbortError')) {
+                streamError = e;
+            }
+        } finally {
+            const pendingIndex = confirmPendingUserMessage(sessionName, pendingMessage.id);
+            if (pendingIndex >= 0 && pendingIndex < state.messageRenderKeys.length) {
+                if (pendingIndex < messagesNode.children.length) {
+                    const pendingRow = messagesNode.children[pendingIndex];
+                    if (pendingRow && pendingRow.classList.contains('pending')) {
+                        pendingRow.classList.remove('pending');
+                    }
+                }
+            }
+            finalizeAgentRunState();
+            syncUi();
+        }
+
+        if (streamError) {
+            throw streamError;
+        }
+        if (!finalResult) {
+            throw new Error('Agent 流式响应未返回结果');
+        }
+
+        appendAssistantMessageLocal(sessionName, finalResult, 'agent');
+        if (state.active === sessionName) {
+            renderMessages(state.messages, { stickToBottom: true });
+        }
+        bumpSessionMetaAfterSend(sessionName);
+        refreshSessionsSilent({ preferredName: sessionName }).catch(function () {
+            // 静默同步失败不打断当前交互
+        });
+    }
+
     if (openConfigBtn) {
         openConfigBtn.addEventListener('click', function () {
             openConfigModal();
@@ -2092,32 +2357,31 @@
         try {
             commandInput.value = '';
             commandInput.focus();
-            const endpoint = mode === 'agent' ? '/agent' : '/run';
-            const runResult = await api('/api/sessions/' + encodeURIComponent(submitSession) + endpoint, {
-                method: 'POST',
-                body: JSON.stringify(
-                    mode === 'agent'
-                        ? { prompt: inputText }
-                        : { command: inputText }
-                )
-            });
-            const pendingIndex = confirmPendingUserMessage(submitSession, pendingMessage.id);
-            if (pendingIndex >= 0 && pendingIndex < state.messageRenderKeys.length) {
-                if (pendingIndex < messagesNode.children.length) {
-                    const pendingRow = messagesNode.children[pendingIndex];
-                    if (pendingRow && pendingRow.classList.contains('pending')) {
-                        pendingRow.classList.remove('pending');
+            if (mode === 'agent') {
+                await sendAgentPromptStream(submitSession, inputText, pendingMessage);
+            } else {
+                const runResult = await api('/api/sessions/' + encodeURIComponent(submitSession) + '/run', {
+                    method: 'POST',
+                    body: JSON.stringify({ command: inputText })
+                });
+                const pendingIndex = confirmPendingUserMessage(submitSession, pendingMessage.id);
+                if (pendingIndex >= 0 && pendingIndex < state.messageRenderKeys.length) {
+                    if (pendingIndex < messagesNode.children.length) {
+                        const pendingRow = messagesNode.children[pendingIndex];
+                        if (pendingRow && pendingRow.classList.contains('pending')) {
+                            pendingRow.classList.remove('pending');
+                        }
                     }
                 }
+                appendAssistantMessageLocal(submitSession, runResult, mode);
+                if (state.active === submitSession) {
+                    renderMessages(state.messages, { stickToBottom: true });
+                }
+                bumpSessionMetaAfterSend(submitSession);
+                refreshSessionsSilent({ preferredName: submitSession }).catch(function () {
+                    // 静默同步失败不打断当前交互
+                });
             }
-            appendAssistantMessageLocal(submitSession, runResult, mode);
-            if (state.active === submitSession) {
-                renderMessages(state.messages, { stickToBottom: true });
-            }
-            bumpSessionMetaAfterSend(submitSession);
-            refreshSessionsSilent({ preferredName: submitSession }).catch(function () {
-                // 静默同步失败不打断当前交互
-            });
         } catch (e) {
             if (state.active === submitSession) {
                 state.messages = state.messages.filter(function (message) {
@@ -2133,6 +2397,26 @@
         }
     });
 
+    if (stopBtn) {
+        stopBtn.addEventListener('click', async function () {
+            if (!state.active || !isAgentRunActiveForSession(state.active) || state.agentRun.stopping) {
+                return;
+            }
+            state.agentRun.stopping = true;
+            syncUi();
+            try {
+                await api('/api/sessions/' + encodeURIComponent(state.active) + '/agent/stop', {
+                    method: 'POST',
+                    body: JSON.stringify({})
+                });
+            } catch (e) {
+                alert(e.message);
+                state.agentRun.stopping = false;
+                syncUi();
+            }
+        });
+    }
+
     commandInput.addEventListener('keydown', function (event) {
         if (event.key !== 'Enter' || event.isComposing) {
             return;

package/lib/web/server.js

@@ -321,6 +321,7 @@ function hasAgentConversationHistory(history) {
     for (const message of messages) {
         if (!message || typeof message !== 'object') continue;
         if (message.mode !== 'agent') continue;
+        if (message.streamTrace === true) continue;
         if (message.role === 'user' || message.role === 'assistant') {
             return true;
         }
@@ -339,7 +340,12 @@ function clipAgentContextMessageText(text) {
 function buildAgentPromptWithHistory(history, prompt) {
     const sessionHistory = history && Array.isArray(history.messages) ? history.messages : [];
     const relevantMessages = sessionHistory
-        .filter(message => message && message.mode === 'agent' && (message.role === 'user' || message.role === 'assistant'))
+        .filter(message => (
+            message
+            && message.mode === 'agent'
+            && message.streamTrace !== true
+            && (message.role === 'user' || message.role === 'assistant')
+        ))
         .slice(-WEB_AGENT_CONTEXT_MAX_MESSAGES);
     if (!relevantMessages.length) {
         return String(prompt || '');
@@ -370,6 +376,198 @@ function buildAgentPromptWithHistory(history, prompt) {
     ].join('\n');
 }
 
+function prepareCodexTraceDisplayLine(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+
+    const eventType = typeof payload.type === 'string' ? payload.type : '';
+    const item = payload.item && typeof payload.item === 'object' && !Array.isArray(payload.item)
+        ? payload.item
+        : {};
+    const itemType = typeof item.type === 'string' ? item.type : '';
+    const text = pickFirstString(
+        item.title,
+        item.summary,
+        item.text,
+        item.name,
+        item.command,
+        payload.message,
+        payload.text
+    );
+    const toolName = pickFirstString(
+        item.name,
+        item.tool_name,
+        item.tool,
+        item.command
+    );
+    const commandText = pickFirstString(item.command);
+    const mcpServer = pickFirstString(item.server);
+    const mcpTool = pickFirstString(item.tool);
+    const itemStatus = pickFirstString(item.status);
+
+    function shortenText(value, maxChars = 140) {
+        const raw = clipText(stripAnsi(String(value || '')).replace(/\s+/g, ' ').trim(), maxChars);
+        return raw.trim();
+    }
+
+    function summarizeArguments(args) {
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+            return '';
+        }
+        const parts = [];
+        for (const [key, value] of Object.entries(args)) {
+            if (value === undefined || value === null) continue;
+            if (typeof value === 'string') {
+                const textValue = value.trim();
+                if (!textValue) continue;
+                parts.push(`${key}=${shortenText(textValue, 80)}`);
+                continue;
+            }
+            if (typeof value === 'number' || typeof value === 'boolean') {
+                parts.push(`${key}=${String(value)}`);
+            }
+        }
+        return parts.slice(0, 3).join(', ');
+    }
+
+    if (eventType === 'thread.started') {
+        return '[会话] Codex 已开始处理';
+    }
+    if (eventType === 'thread.completed') {
+        return '[会话] Codex 已完成当前任务';
+    }
+    if (eventType === 'turn.started') {
+        return '[回合] 开始生成响应';
+    }
+    if (eventType === 'turn.completed') {
+        return '[回合] 响应完成';
+    }
+    if (eventType === 'item.started') {
+        if (itemType === 'tool_call') {
+            return `[工具开始] ${toolName || 'tool_call'}`;
+        }
+        if (itemType === 'command_execution') {
+            return `[命令开始] ${commandText || 'command_execution'}`;
+        }
+        if (itemType === 'mcp_tool_call') {
+            const summary = summarizeArguments(item.arguments);
+            return summary
+                ? `[MCP开始] ${mcpServer || 'mcp'}.${mcpTool || 'tool'} (${summary})`
+                : `[MCP开始] ${mcpServer || 'mcp'}.${mcpTool || 'tool'}`;
+        }
+        if (itemType === 'reasoning') {
+            return text ? `[状态] ${text}` : '[状态] Codex 正在分析';
+        }
+        if (itemType === 'agent_message') {
+            return text ? `[说明] ${text}` : '[回复] 正在生成最终答复';
+        }
+        return text ? `[事件开始] ${text}` : `[事件开始] ${itemType || eventType}`;
+    }
+    if (eventType === 'item.completed') {
+        if (itemType === 'tool_call') {
+            return `[工具完成] ${toolName || 'tool_call'}`;
+        }
+        if (itemType === 'command_execution') {
+            const suffix = itemStatus || (typeof item.exit_code === 'number' ? `exit=${item.exit_code}` : 'completed');
+            return `[命令完成] ${commandText || 'command_execution'} (${suffix})`;
+        }
+        if (itemType === 'mcp_tool_call') {
+            const summary = summarizeArguments(item.arguments);
+            return summary
+                ? `[MCP完成] ${mcpServer || 'mcp'}.${mcpTool || 'tool'} (${summary})`
+                : `[MCP完成] ${mcpServer || 'mcp'}.${mcpTool || 'tool'}`;
+        }
+        if (itemType === 'reasoning') {
+            return text ? `[状态] ${text}` : '';
+        }
+        if (itemType === 'agent_message') {
+            return text ? `[说明] ${text}` : '[回复] 已生成';
+        }
+        return text ? `[事件完成] ${text}` : `[事件完成] ${itemType || eventType}`;
+    }
+    if (eventType === 'error') {
+        return text ? `[错误] ${text}` : '[错误] Codex 返回了错误事件';
+    }
+
+    return `[事件] ${eventType}`;
+}
+
+async function prepareWebAgentExecution(ctx, state, containerName, prompt) {
+    const history = loadWebSessionHistory(state.webHistoryDir, containerName);
+    const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
+    if (normalizedTemplate !== history.agentPromptCommand) {
+        history.agentPromptCommand = normalizedTemplate;
+        saveWebSessionHistory(state.webHistoryDir, containerName, history);
+    }
+    if (!isAgentPromptCommandEnabled(history.agentPromptCommand)) {
+        throw new Error('当前会话未配置 agentPromptCommand');
+    }
+
+    await ensureWebContainer(ctx, state, containerName);
+    const agentMeta = getAgentRuntimeMeta(history);
+    const hasPriorConversation = hasAgentConversationHistory(history);
+    let resumeAttempted = false;
+    let resumeSucceeded = false;
+    let resumeError = '';
+
+    if (hasPriorConversation && agentMeta.resumeSupported && agentMeta.resumeCommand) {
+        resumeAttempted = true;
+        const resumeResult = await execCommandInWebContainer(ctx, containerName, agentMeta.resumeCommand);
+        if (resumeResult.exitCode === 0) {
+            resumeSucceeded = true;
+        } else {
+            resumeError = clipText(String(resumeResult.output || '(无输出)'), 1200);
+        }
+    }
+
+    const effectivePrompt = resumeSucceeded
+        ? prompt
+        : buildAgentPromptWithHistory(history, prompt);
+    const command = buildWebAgentExecCommand(history.agentPromptCommand, effectivePrompt, agentMeta.agentProgram);
+    const contextMode = resumeSucceeded ? 'resume' : (hasPriorConversation ? 'history-injected' : 'first-turn');
+
+    return {
+        history,
+        agentMeta,
+        command,
+        contextMode,
+        resumeAttempted,
+        resumeSucceeded,
+        resumeError
+    };
+}
+
+function finalizeWebAgentExecution(state, containerName, history, agentMeta, meta, result) {
+    appendWebSessionMessage(state.webHistoryDir, containerName, 'assistant', result.output, {
+        exitCode: result.exitCode,
+        mode: 'agent',
+        contextMode: meta.contextMode,
+        resumeAttempted: meta.resumeAttempted,
+        resumeSucceeded: meta.resumeSucceeded,
+        interrupted: result.interrupted === true
+    });
+    patchWebSessionAgentState(state.webHistoryDir, containerName, {
+        agentProgram: agentMeta.agentProgram,
+        resumeSupported: agentMeta.resumeSupported,
+        lastResumeAt: meta.resumeAttempted ? new Date().toISOString() : history.lastResumeAt || null,
+        lastResumeOk: meta.resumeAttempted ? meta.resumeSucceeded : history.lastResumeOk,
+        lastResumeError: meta.resumeAttempted ? (meta.resumeSucceeded ? '' : meta.resumeError) : history.lastResumeError || ''
+    });
+}
+
+function appendWebAgentTraceMessage(webHistoryDir, containerName, content, extra = {}) {
+    const text = String(content || '').trim();
+    if (!text) {
+        return;
+    }
+    appendWebSessionMessage(webHistoryDir, containerName, 'assistant', text, {
+        mode: 'agent',
+        streamTrace: true,
+        ...extra
+    });
+}
+
 function secureStringEqual(a, b) {
     const aStr = String(a || '');
     const bStr = String(b || '');
@@ -1177,6 +1375,145 @@ async function execCommandInWebContainer(ctx, containerName, command) {
     });
 }
 
+async function execAgentInWebContainerStream(ctx, state, containerName, command, options = {}) {
+    const opts = options && typeof options === 'object' ? options : {};
+    const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
+    const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : () => {};
+    const process = spawn(
+        ctx.dockerCmd,
+        ['exec', containerName, '/bin/bash', '-lc', command],
+        { stdio: ['ignore', 'pipe', 'pipe'] }
+    );
+
+    const runState = {
+        containerName,
+        process,
+        command,
+        startedAt: new Date().toISOString(),
+        stopping: false
+    };
+    state.agentRuns.set(containerName, runState);
+
+    return await new Promise((resolve, reject) => {
+        const MAX_RAW_OUTPUT_CHARS = 32 * 1024 * 1024;
+        let stdoutOutput = '';
+        let stderrOutput = '';
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let stdoutPending = '';
+        let stderrPending = '';
+        function appendChunk(chunk, target) {
+            if (!chunk) return;
+            const text = chunk.toString('utf-8');
+            if (!text) return;
+            if (target.value.length >= MAX_RAW_OUTPUT_CHARS) {
+                target.truncated = true;
+                return;
+            }
+            const remain = MAX_RAW_OUTPUT_CHARS - target.value.length;
+            if (text.length > remain) {
+                target.value += text.slice(0, remain);
+                target.truncated = true;
+                return;
+            }
+            target.value += text;
+        }
+
+        function emitStdoutTraceLine(line) {
+            const rawLine = String(line || '').trim();
+            if (!rawLine) {
+                return;
+            }
+            if (agentProgram === 'codex') {
+                let payload = null;
+                try {
+                    payload = JSON.parse(rawLine);
+                } catch (e) {
+                    payload = null;
+                }
+                if (payload) {
+                    const display = prepareCodexTraceDisplayLine(payload);
+                    if (display) {
+                        onEvent({ type: 'trace', stream: 'stdout', text: display });
+                    }
+                    return;
+                }
+                if (/^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}` });
+        }
+
+        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;
+        }
+
+        process.stdout.on('data', chunk => {
+            appendChunk(chunk, {
+                get value() { return stdoutOutput; },
+                set value(nextValue) { stdoutOutput = nextValue; },
+                get truncated() { return stdoutTruncated; },
+                set truncated(nextValue) { stdoutTruncated = nextValue; }
+            });
+            stdoutPending = drainLines(chunk.toString('utf-8'), stdoutPending, emitStdoutTraceLine);
+        });
+        process.stderr.on('data', chunk => {
+            appendChunk(chunk, {
+                get value() { return stderrOutput; },
+                set value(nextValue) { stderrOutput = nextValue; },
+                get truncated() { return stderrTruncated; },
+                set truncated(nextValue) { stderrTruncated = nextValue; }
+            });
+            stderrPending = drainLines(chunk.toString('utf-8'), stderrPending, emitStderrTraceLine);
+        });
+
+        process.on('error', error => {
+            state.agentRuns.delete(containerName);
+            reject(error);
+        });
+        process.on('close', code => {
+            state.agentRuns.delete(containerName);
+            if (stdoutPending) {
+                emitStdoutTraceLine(stdoutPending);
+                stdoutPending = '';
+            }
+            if (stderrPending) {
+                emitStderrTraceLine(stderrPending);
+                stderrPending = '';
+            }
+            const exitCode = typeof code === 'number' ? code : 1;
+            const clippedStdout = stdoutTruncated ? `${stdoutOutput}\n...[stdout-truncated]` : stdoutOutput;
+            const clippedStderr = stderrTruncated ? `${stderrOutput}\n...[stderr-truncated]` : stderrOutput;
+            const clippedRaw = `${clippedStdout}${clippedStdout && clippedStderr ? '\n' : ''}${clippedStderr}`;
+            const extractedJsonAgentMessage = extractAgentMessageFromCodexJsonl(clippedStdout);
+            const cleanOutputSource = extractedJsonAgentMessage || clippedRaw;
+            const output = clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
+            resolve({
+                exitCode,
+                output,
+                interrupted: exitCode !== 0 && runState.stopping === true
+            });
+        });
+    });
+}
+
 function readRequestBody(req) {
     return new Promise((resolve, reject) => {
         let body = '';
@@ -1213,6 +1550,24 @@ function sendJson(res, statusCode, payload, extraHeaders = {}) {
     res.end(JSON.stringify(payload));
 }
 
+function sendNdjson(res, payload) {
+    res.write(`${JSON.stringify(payload)}\n`);
+}
+
+function 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 (e) {
+        return false;
+    }
+    return true;
+}
+
 function sendHtml(res, statusCode, html, extraHeaders = {}) {
     res.writeHead(statusCode, {
         'Content-Type': 'text/html; charset=utf-8',
@@ -1807,72 +2162,156 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     return;
                 }
 
-                const history = loadWebSessionHistory(state.webHistoryDir, containerName);
-                const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
-                if (normalizedTemplate !== history.agentPromptCommand) {
-                    history.agentPromptCommand = normalizedTemplate;
-                    saveWebSessionHistory(state.webHistoryDir, containerName, history);
-                }
-                if (!isAgentPromptCommandEnabled(history.agentPromptCommand)) {
-                    sendJson(res, 400, { error: '当前会话未配置 agentPromptCommand' });
+                let prepared = null;
+                try {
+                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                } catch (e) {
+                    sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
                     return;
                 }
 
-                await ensureWebContainer(ctx, state, containerName);
-                const agentMeta = getAgentRuntimeMeta(history);
-                const hasPriorConversation = hasAgentConversationHistory(history);
-                let resumeAttempted = false;
-                let resumeSucceeded = false;
-                let resumeError = '';
-                if (hasPriorConversation && agentMeta.resumeSupported && agentMeta.resumeCommand) {
-                    resumeAttempted = true;
-                    const resumeResult = await execCommandInWebContainer(ctx, containerName, agentMeta.resumeCommand);
-                    if (resumeResult.exitCode === 0) {
-                        resumeSucceeded = true;
-                    } else {
-                        resumeError = clipText(String(resumeResult.output || '(无输出)'), 1200);
-                    }
-                }
-
-                const effectivePrompt = resumeSucceeded
-                    ? prompt
-                    : buildAgentPromptWithHistory(history, prompt);
-                const command = buildWebAgentExecCommand(history.agentPromptCommand, effectivePrompt, agentMeta.agentProgram);
-                const contextMode = resumeSucceeded ? 'resume' : (hasPriorConversation ? 'history-injected' : 'first-turn');
+                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
                 appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
                     mode: 'agent',
                     contextMode
                 });
                 const result = await execCommandInWebContainer(ctx, containerName, command);
-                appendWebSessionMessage(
-                    state.webHistoryDir,
-                    containerName,
-                    'assistant',
-                    result.output,
-                    {
-                        exitCode: result.exitCode,
-                        mode: 'agent',
-                        contextMode,
-                        resumeAttempted,
-                        resumeSucceeded
-                    }
-                );
-                patchWebSessionAgentState(state.webHistoryDir, containerName, {
-                    agentProgram: agentMeta.agentProgram,
-                    resumeSupported: agentMeta.resumeSupported,
-                    lastResumeAt: resumeAttempted ? new Date().toISOString() : history.lastResumeAt || null,
-                    lastResumeOk: resumeAttempted ? resumeSucceeded : history.lastResumeOk,
-                    lastResumeError: resumeAttempted ? (resumeSucceeded ? '' : resumeError) : history.lastResumeError || ''
-                });
+                finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                    contextMode,
+                    resumeAttempted,
+                    resumeSucceeded,
+                    resumeError
+                }, result);
                 sendJson(res, 200, {
                     exitCode: result.exitCode,
                     output: result.output,
                     contextMode,
                     resumeAttempted,
-                    resumeSucceeded
+                    resumeSucceeded,
+                    interrupted: result.interrupted === true
                 });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stream$/),
+            handler: async match => {
+                const containerName = getValidSessionName(ctx, res, match[1]);
+                if (!containerName) {
+                    return;
+                }
+
+                const payload = await readJsonBody(req);
+                const prompt = (payload.prompt || '').trim();
+                if (!prompt) {
+                    sendJson(res, 400, { error: 'prompt 不能为空' });
+                    return;
+                }
+                if (state.agentRuns.has(containerName)) {
+                    sendJson(res, 409, { error: '当前会话已有运行中的 agent 任务' });
+                    return;
+                }
+
+                let prepared = null;
+                try {
+                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                } catch (e) {
+                    sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
+                    return;
+                }
+
+                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
+                const traceLines = ['[执行过程]'];
+                appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
+                    mode: 'agent',
+                    contextMode
+                });
+
+                res.writeHead(200, {
+                    'Content-Type': 'application/x-ndjson; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                    'X-Accel-Buffering': 'no'
+                });
+                sendNdjson(res, {
+                    type: 'meta',
+                    containerName,
+                    contextMode,
+                    resumeAttempted,
+                    resumeSucceeded,
+                    agentProgram: agentMeta.agentProgram
+                });
+                if (contextMode) {
+                    traceLines.push(`上下文模式: ${contextMode}`);
+                }
+                if (resumeAttempted) {
+                    traceLines.push(resumeSucceeded ? '会话恢复成功' : '会话恢复失败，已回退到历史注入');
+                }
+
+                try {
+                    const result = await execAgentInWebContainerStream(ctx, state, containerName, command, {
+                        agentProgram: agentMeta.agentProgram,
+                        onEvent: event => {
+                            if (event && event.type === 'trace' && event.text) {
+                                traceLines.push(String(event.text));
+                            }
+                            sendNdjson(res, event);
+                        }
+                    });
+                    traceLines.push(result.interrupted === true ? '[任务] 已停止' : '[任务] 已完成');
+                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: result.interrupted === true
+                    });
+                    finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        resumeError
+                    }, result);
+                    sendNdjson(res, {
+                        type: 'result',
+                        exitCode: result.exitCode,
+                        output: result.output,
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: result.interrupted === true
+                    });
+                } catch (e) {
+                    traceLines.push(`[错误] ${e && e.message ? e.message : 'Agent 执行失败'}`);
+                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: true
+                    });
+                    sendNdjson(res, {
+                        type: 'error',
+                        error: e && e.message ? e.message : 'Agent 执行失败'
+                    });
+                } finally {
+                    res.end();
+                }
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stop$/),
+            handler: async match => {
+                const containerName = getValidSessionName(ctx, res, match[1]);
+                if (!containerName) {
+                    return;
+                }
+                const stopped = stopWebAgentRun(state, containerName);
+                if (!stopped) {
+                    sendJson(res, 404, { error: '当前会话没有运行中的 agent 任务' });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, stopping: true });
+            }
+        },
         {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/remove$/),
@@ -1971,7 +2410,8 @@ async function startWebServer(options) {
         webHistoryDir: options.webHistoryDir || path.join(os.homedir(), '.manyoyo', 'web-history'),
         webConfigPath: options.webConfigPath || getDefaultWebConfigPath(),
         authSessions: new Map(),
-        terminalSessions: new Map()
+        terminalSessions: new Map(),
+        agentRuns: new Map()
     };
 
     ensureWebHistoryDir(state.webHistoryDir);
@@ -2197,6 +2637,13 @@ async function startWebServer(options) {
                 }
             }
             state.terminalSessions.clear();
+            for (const runState of state.agentRuns.values()) {
+                const child = runState && runState.process;
+                if (child && !child.killed) {
+                    try { child.kill('SIGTERM'); } catch (e) {}
+                }
+            }
+            state.agentRuns.clear();
 
             const closeHttp = () => {
                 if (!server.listening) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.6.8",
+    "version": "5.6.9",
     "imageVersion": "1.9.0-common",
     "playwrightCliVersion": "0.1.1",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",