@xcanwin/manyoyo 5.9.3 → 5.10.3

package/lib/web/server.js

@@ -34,7 +34,8 @@ const WEB_TERMINAL_MIN_ROWS = 12;
 const WEB_AGENT_CONTEXT_MAX_MESSAGES = 24;
 const WEB_AGENT_CONTEXT_MAX_CHARS = 6000;
 const WEB_AGENT_CONTEXT_PER_MESSAGE_MAX_CHARS = 600;
-const WEB_FILE_PREVIEW_MAX_BYTES = 256 * 1024;
+const WEB_FILE_PREVIEW_MAX_BYTES = 512 * 1024;
+const WEB_FILE_EDIT_MAX_BYTES = 2 * 1024 * 1024;
 const WEB_AUTH_COOKIE_NAME = 'manyoyo_web_auth';
 const WEB_AUTH_TTL_SECONDS = 12 * 60 * 60;
 const WEB_SESSION_KEY_SEPARATOR = '~';
@@ -2657,7 +2658,12 @@ async function execCommandInWebContainer(ctx, containerName, command, options =
             const extractedAgentMessage = extractAgentMessageFromStructuredOutput(agentProgram, clippedStdout);
             const cleanOutputSource = extractedAgentMessage || clippedRaw;
             const output = clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
-            resolve({ exitCode, output });
+            resolve({
+                exitCode,
+                output,
+                stdout: clippedStdout,
+                stderr: clippedStderr
+            });
         });
     });
 }
@@ -2679,7 +2685,7 @@ async function execJsonCommandInWebContainer(ctx, containerName, command) {
         throw new Error(result.output || '容器命令执行失败');
     }
     try {
-        return JSON.parse(String(result.output || '{}'));
+        return JSON.parse(String(result.stdout || '{}'));
     } catch (e) {
         throw new Error('容器返回了无法解析的 JSON');
     }
@@ -2748,13 +2754,17 @@ try {
 `);
 }
 
-function buildContainerFileReadCommand(requestedPath) {
+function buildContainerFileReadCommand(requestedPath, options = {}) {
+    const opts = options && typeof options === 'object' ? options : {};
+    const maxBytes = Number.isFinite(opts.maxBytes) && opts.maxBytes > 0
+        ? Math.floor(opts.maxBytes)
+        : 0;
     return buildWebContainerNodeCommand(`
 // __MANYOYO_FS_READ__
 const fs = require('fs');
 
 const requestedPath = ${JSON.stringify(String(requestedPath || ''))};
-const maxBytes = ${String(WEB_FILE_PREVIEW_MAX_BYTES)};
+const maxBytes = ${String(maxBytes)};
 
 function looksBinary(buffer) {
     const length = Math.min(buffer.length, 4096);
@@ -2779,7 +2789,7 @@ try {
     }
 
     const size = stat.size;
-    const readBytes = Math.min(size, maxBytes);
+    const readBytes = maxBytes > 0 ? Math.min(size, maxBytes) : size;
     const buffer = Buffer.alloc(readBytes);
     const fd = fs.openSync(realPath, 'r');
     try {
@@ -2793,14 +2803,14 @@ try {
             path: realPath,
             kind: 'binary',
             size,
-            truncated: size > maxBytes
+            truncated: maxBytes > 0 && size > maxBytes
         }));
     } else {
         process.stdout.write(JSON.stringify({
             path: realPath,
             kind: 'text',
             size,
-            truncated: size > maxBytes,
+            truncated: maxBytes > 0 && size > maxBytes,
             content: buffer.toString('utf8')
         }));
     }
@@ -2812,6 +2822,71 @@ try {
 `);
 }
 
+function buildContainerFileWriteCommand(requestedPath, content) {
+    return buildWebContainerNodeCommand(`
+// __MANYOYO_FS_WRITE__
+const fs = require('fs');
+
+const requestedPath = ${JSON.stringify(String(requestedPath || ''))};
+const nextContent = ${JSON.stringify(String(content == null ? '' : content))};
+
+try {
+    const realPath = fs.realpathSync(requestedPath);
+    const stat = fs.statSync(realPath);
+    if (!stat.isFile()) {
+        throw new Error('目标不是文件: ' + realPath);
+    }
+
+    fs.writeFileSync(realPath, nextContent, 'utf8');
+    const savedStat = fs.statSync(realPath);
+    process.stdout.write(JSON.stringify({
+        path: realPath,
+        saved: true,
+        size: savedStat.size
+    }));
+} catch (e) {
+    process.stdout.write(JSON.stringify({
+        error: e && e.message ? e.message : '保存文件失败'
+    }));
+}
+`);
+}
+
+function buildContainerFileMkdirCommand(requestedPath) {
+    return buildWebContainerNodeCommand(`
+// __MANYOYO_FS_MKDIR__
+const fs = require('fs');
+const path = require('path');
+
+const requestedPath = ${JSON.stringify(String(requestedPath || ''))};
+
+try {
+    const resolvedPath = path.resolve(requestedPath);
+    const parentPath = path.dirname(resolvedPath);
+    const realParentPath = fs.realpathSync(parentPath);
+    const targetPath = path.join(realParentPath, path.basename(resolvedPath));
+    if (fs.existsSync(targetPath)) {
+        throw new Error('目录已存在: ' + targetPath);
+    }
+
+    fs.mkdirSync(targetPath, { recursive: true });
+    const stat = fs.statSync(targetPath);
+    process.stdout.write(JSON.stringify({
+        path: targetPath,
+        name: path.basename(targetPath),
+        kind: 'directory',
+        size: 0,
+        mtimeMs: stat.mtimeMs,
+        created: true
+    }));
+} catch (e) {
+    process.stdout.write(JSON.stringify({
+        error: e && e.message ? e.message : '创建目录失败'
+    }));
+}
+`);
+}
+
 async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerName, command, options = {}) {
     const opts = options && typeof options === 'object' ? options : {};
     const sessionRef = typeof sessionRefOrContainerName === 'string'
@@ -3090,7 +3165,12 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef) {
             defaultCommand: containerInfo.defaultCommand || ''
         });
     const createdAt = agentSession.createdAt || containerInfo.createdAt || null;
-    const updatedAt = agentSession.updatedAt || history.updatedAt || (latestMessage && latestMessage.timestamp) || containerInfo.createdAt || null;
+    const updatedAt = agentSession.updatedAt
+        || (latestMessage && latestMessage.timestamp)
+        || (agentId === WEB_DEFAULT_AGENT_ID
+            ? (history.updatedAt || containerInfo.createdAt)
+            : null)
+        || null;
     return {
         name: buildWebSessionKey(containerName, agentId),
         containerName,
@@ -3583,6 +3663,25 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath === '/api/fs/directories/mkdir' ? [] : null,
+            handler: async () => {
+                const payload = await readJsonBody(req);
+                const requestedPath = expandHomeAliasPath(String(payload && payload.path ? payload.path : '').trim());
+                if (!requestedPath) {
+                    sendJson(res, 400, { error: 'path 不能为空' });
+                    return;
+                }
+
+                const targetPath = path.resolve(requestedPath);
+                fs.mkdirSync(targetPath, { recursive: true });
+                sendJson(res, 200, {
+                    path: targetPath,
+                    created: true
+                });
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath === '/api/config' ? [] : null,
@@ -3742,6 +3841,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 }
                 const requestUrl = new URL(req.url || '/api/sessions/x/fs/read', 'http://localhost');
                 const targetPath = String(requestUrl.searchParams.get('path') || '').trim();
+                const fullRequested = ['1', 'true', 'yes'].includes(String(requestUrl.searchParams.get('full') || '').toLowerCase());
                 if (!targetPath) {
                     sendJson(res, 400, { error: 'path 不能为空' });
                     return;
@@ -3751,7 +3851,9 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 const payload = await execJsonCommandInWebContainer(
                     ctx,
                     sessionRef.containerName,
-                    buildContainerFileReadCommand(targetPath)
+                    buildContainerFileReadCommand(targetPath, {
+                        maxBytes: fullRequested ? 0 : WEB_FILE_PREVIEW_MAX_BYTES
+                    })
                 );
                 if (payload && payload.error) {
                     sendJson(res, 400, { error: payload.error });
@@ -3759,10 +3861,77 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 }
                 if (payload && payload.kind === 'text') {
                     payload.language = inferFileLanguage(payload.path);
+                    payload.editable = payload.truncated !== true
+                        && Number(payload.size || 0) < WEB_FILE_EDIT_MAX_BYTES;
                 }
                 sendJson(res, 200, payload);
             }
         },
+        {
+            method: 'PUT',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/fs\/write$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const targetPath = String(payload && payload.path ? payload.path : '').trim();
+                const content = typeof payload.content === 'string' ? payload.content : null;
+                if (!targetPath) {
+                    sendJson(res, 400, { error: 'path 不能为空' });
+                    return;
+                }
+                if (content === null) {
+                    sendJson(res, 400, { error: 'content 必须是字符串' });
+                    return;
+                }
+                if (Buffer.byteLength(content, 'utf8') >= WEB_FILE_EDIT_MAX_BYTES) {
+                    sendJson(res, 400, { error: '文件过大，当前仅支持编辑小于 2MB 的文本文件' });
+                    return;
+                }
+
+                await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+                const result = await execJsonCommandInWebContainer(
+                    ctx,
+                    sessionRef.containerName,
+                    buildContainerFileWriteCommand(targetPath, content)
+                );
+                if (result && result.error) {
+                    sendJson(res, 400, { error: result.error });
+                    return;
+                }
+                sendJson(res, 200, result);
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/fs\/mkdir$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const targetPath = String(payload && payload.path ? payload.path : '').trim();
+                if (!targetPath) {
+                    sendJson(res, 400, { error: 'path 不能为空' });
+                    return;
+                }
+
+                await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+                const result = await execJsonCommandInWebContainer(
+                    ctx,
+                    sessionRef.containerName,
+                    buildContainerFileMkdirCommand(targetPath)
+                );
+                if (result && result.error) {
+                    sendJson(res, 400, { error: result.error });
+                    return;
+                }
+                sendJson(res, 200, result);
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/detail$/),

package/lib/worktrees.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function defaultRunGitCommand(targetPath, args) {
+    const result = spawnSync('git', ['-C', targetPath, ...args], {
+        encoding: 'utf-8'
+    });
+
+    if (result.status !== 0) {
+        const stderr = String(result.stderr || '').trim();
+        throw new Error(stderr || `git ${args.join(' ')} 执行失败`);
+    }
+
+    return String(result.stdout || '').trim();
+}
+
+function normalizeAbsolutePath(targetPath) {
+    return path.resolve(String(targetPath || '').trim());
+}
+
+function isDescendantPath(parentPath, targetPath) {
+    const relativePath = path.relative(parentPath, targetPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
+function detectGitWorktreeContext(targetPath, deps = {}) {
+    const fsApi = deps.fs || fs;
+    const pathApi = deps.path || path;
+    const runGitCommand = deps.runGitCommand || defaultRunGitCommand;
+    const absoluteTargetPath = normalizeAbsolutePath(targetPath);
+
+    if (!fsApi.existsSync(absoluteTargetPath)) {
+        throw new Error(`启用 --worktrees 时宿主机路径不存在: ${absoluteTargetPath}`);
+    }
+
+    const stats = fsApi.statSync(absoluteTargetPath);
+    if (!stats.isDirectory()) {
+        throw new Error(`启用 --worktrees 时宿主机路径必须为目录: ${absoluteTargetPath}`);
+    }
+
+    let repoRoot;
+    let commonDirRaw;
+    try {
+        repoRoot = pathApi.resolve(runGitCommand(absoluteTargetPath, ['rev-parse', '--show-toplevel']));
+        commonDirRaw = runGitCommand(absoluteTargetPath, ['rev-parse', '--git-common-dir']);
+    } catch (error) {
+        throw new Error(`启用 --worktrees 失败: ${absoluteTargetPath} 不在 Git 仓库内`);
+    }
+
+    const commonDir = pathApi.isAbsolute(commonDirRaw)
+        ? pathApi.normalize(commonDirRaw)
+        : pathApi.resolve(repoRoot, commonDirRaw);
+    const mainRepoRoot = pathApi.dirname(commonDir);
+    const projectName = pathApi.basename(mainRepoRoot);
+
+    return {
+        targetPath: absoluteTargetPath,
+        repoRoot,
+        mainRepoRoot,
+        isWorktree: repoRoot !== mainRepoRoot,
+        projectName,
+        defaultWorktreesRoot: pathApi.join(pathApi.dirname(mainRepoRoot), 'worktrees', projectName)
+    };
+}
+
+function shouldAddSamePathMount(hostPath, containerPath, targetPath) {
+    if (hostPath !== containerPath) {
+        return true;
+    }
+    return !isDescendantPath(hostPath, targetPath);
+}
+
+function resolveWorktreeSupport(options = {}, deps = {}) {
+    const fsApi = deps.fs || fs;
+    const pathApi = deps.path || path;
+    const enabled = options.enabled === true || Boolean(options.worktreesRoot);
+
+    if (!enabled) {
+        return {
+            enabled: false,
+            worktreesRoot: null,
+            worktreeRepoRoot: null,
+            worktreeMainRepoRoot: null,
+            extraVolumes: []
+        };
+    }
+
+    const hostPath = normalizeAbsolutePath(options.hostPath);
+    const containerPath = String(options.containerPath || hostPath).trim() || hostPath;
+    const detected = detectGitWorktreeContext(hostPath, deps);
+    let worktreesRoot = options.worktreesRoot;
+
+    if (worktreesRoot !== undefined && worktreesRoot !== null && String(worktreesRoot).trim() !== '') {
+        if (!pathApi.isAbsolute(worktreesRoot)) {
+            throw new Error(`--worktrees-root 仅支持绝对路径: ${worktreesRoot}`);
+        }
+        worktreesRoot = pathApi.resolve(worktreesRoot);
+    } else {
+        worktreesRoot = detected.defaultWorktreesRoot;
+    }
+
+    fsApi.mkdirSync(worktreesRoot, { recursive: true });
+
+    const existingVolumes = new Set((options.volumes || []).map(item => String(item)));
+    const extraVolumes = [];
+    [detected.mainRepoRoot, worktreesRoot].forEach(targetPath => {
+        if (!shouldAddSamePathMount(hostPath, containerPath, targetPath)) {
+            return;
+        }
+        const volume = `${targetPath}:${targetPath}`;
+        if (existingVolumes.has(volume) || extraVolumes.includes(volume)) {
+            return;
+        }
+        extraVolumes.push(volume);
+    });
+
+    return {
+        enabled: true,
+        worktreesRoot,
+        worktreeRepoRoot: detected.repoRoot,
+        worktreeMainRepoRoot: detected.mainRepoRoot,
+        extraVolumes
+    };
+}
+
+module.exports = {
+    detectGitWorktreeContext,
+    resolveWorktreeSupport
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.9.3",
+    "version": "5.10.3",
     "imageVersion": "1.9.0-common",
     "playwrightCliVersion": "0.1.1",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",
@@ -87,6 +87,7 @@
         "esbuild": "^0.25.12",
         "glob": "^13.0.6",
         "minimatch": "^10.2.2",
+        "postcss": "^8.5.10",
         "test-exclude": "^8.0.0",
         "vite": "^6.4.2"
     },