@xcanwin/manyoyo 6.2.4 → 6.2.6

package/lib/web/server.js

@@ -157,11 +157,21 @@ function normalizeWebAgentName(agentId, agentName) {
     return String(agentId || '').trim() || WEB_DEFAULT_AGENT_NAME;
 }
 
+const WEB_REMARK_MAX_LENGTH = 200;
+
+function normalizeRemarkText(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim().slice(0, WEB_REMARK_MAX_LENGTH);
+}
+
 function createEmptyWebAgentSession(agentId, agentName) {
     return {
         agentId,
         agentName: normalizeWebAgentName(agentId, agentName),
         agentPromptCommand: '',
+        remark: '',
         createdAt: null,
         updatedAt: null,
         messages: [],
@@ -181,6 +191,7 @@ function normalizeWebAgentSessionRecord(agentId, rawAgent) {
         agentPromptCommand: typeof source.agentPromptCommand === 'string'
             ? normalizeAgentPromptCommandTemplate(source.agentPromptCommand, `agents.${agentId}.agentPromptCommand`)
             : '',
+        remark: normalizeRemarkText(source.remark),
         createdAt: typeof source.createdAt === 'string' ? source.createdAt : null,
         updatedAt: typeof source.updatedAt === 'string' ? source.updatedAt : null,
         messages: Array.isArray(source.messages) ? source.messages : [],
@@ -244,6 +255,9 @@ function normalizeWebHistoryRecord(containerName, rawData) {
     const applied = data.applied && typeof data.applied === 'object' && !Array.isArray(data.applied)
         ? data.applied
         : null;
+    const runtimeSnapshot = data.runtimeSnapshot && typeof data.runtimeSnapshot === 'object' && !Array.isArray(data.runtimeSnapshot)
+        ? data.runtimeSnapshot
+        : null;
     const history = {
         containerName,
         updatedAt: typeof data.updatedAt === 'string' ? data.updatedAt : null,
@@ -251,7 +265,10 @@ function normalizeWebHistoryRecord(containerName, rawData) {
             typeof data.agentPromptCommand === 'string' ? data.agentPromptCommand : '',
             applied
         ),
+        remark: normalizeRemarkText(data.remark),
         applied,
+        // 服务端内部字段，绝不能被 buildSessionSummary/buildSessionDetail/buildSessionAudit 引用或透传给前端。
+        runtimeSnapshot,
         agents: {}
     };
 
@@ -2547,6 +2564,24 @@ function buildCreateRuntime(ctx, state, payload) {
         containerPorts,
         agentPromptCommand,
         defaultCommand: buildDefaultCommand(shellPrefix, shell, shellSuffix) || '/bin/bash',
+        // 仅供服务端内部复用（如"创建相同配置容器"/"复制容器"），绝不能透传给任何对外响应字段，
+        // 因为 env/volumes/ports 可能包含密钥原始值（对外响应向来只暴露 envCount 等计数）。
+        runtimeSnapshot: {
+            hostPath,
+            containerPath,
+            imageName,
+            imageVersion,
+            containerMode,
+            shellPrefix: shellPrefix || '',
+            shell: shell || '',
+            shellSuffix: shellSuffix || '',
+            agentPromptCommand: configuredAgentPromptCommand,
+            yolo: yolo || '',
+            env: resolvedBase.env || {},
+            envFile: resolvedBase.envFile || [],
+            volumes: resolvedBase.volumes || [],
+            ports: resolvedBase.ports || []
+        },
         applied: {
             containerName,
             hostPath,
@@ -2569,6 +2604,138 @@ function buildCreateRuntime(ctx, state, payload) {
     };
 }
 
+function resolveUniqueContainerName(ctx, state, baseName) {
+    const containerMap = listWebManyoyoContainers(ctx);
+    const historyNames = listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName);
+    const taken = new Set([...Object.keys(containerMap), ...historyNames]);
+    // 基于历史最大编号 +1 命名，即使较小编号的副本被删除也不回收其编号，
+    // 避免"删除 -copy1 后新副本又叫 -copy1"造成的名称语义混乱。
+    const escapedBase = baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`^${escapedBase}-copy(\\d+)$`);
+    let maxN = 0;
+    taken.forEach(name => {
+        const matched = name.match(pattern);
+        if (matched) {
+            const n = Number(matched[1]);
+            if (Number.isFinite(n) && n > maxN) {
+                maxN = n;
+            }
+        }
+    });
+    return `${baseName}-copy${maxN + 1}`;
+}
+
+function buildCloneCreateOptionsFromSnapshot(runtimeSnapshot, fallbackHistory) {
+    if (runtimeSnapshot && typeof runtimeSnapshot === 'object') {
+        return {
+            hostPath: runtimeSnapshot.hostPath || '',
+            containerPath: runtimeSnapshot.containerPath || '',
+            imageName: runtimeSnapshot.imageName || '',
+            imageVersion: runtimeSnapshot.imageVersion || '',
+            containerMode: runtimeSnapshot.containerMode || '',
+            shellPrefix: runtimeSnapshot.shellPrefix || '',
+            shell: runtimeSnapshot.shell || '',
+            shellSuffix: runtimeSnapshot.shellSuffix || '',
+            agentPromptCommand: runtimeSnapshot.agentPromptCommand || '',
+            yolo: runtimeSnapshot.yolo || '',
+            env: runtimeSnapshot.env || {},
+            envFile: runtimeSnapshot.envFile || [],
+            volumes: runtimeSnapshot.volumes || [],
+            ports: runtimeSnapshot.ports || []
+        };
+    }
+
+    const applied = fallbackHistory && fallbackHistory.applied && typeof fallbackHistory.applied === 'object'
+        ? fallbackHistory.applied
+        : {};
+    return {
+        hostPath: applied.hostPath || '',
+        containerPath: applied.containerPath || '',
+        imageName: applied.imageName || '',
+        imageVersion: applied.imageVersion || '',
+        containerMode: applied.containerMode || '',
+        shellPrefix: applied.shellPrefix || '',
+        shell: applied.shell || '',
+        shellSuffix: applied.shellSuffix || '',
+        agentPromptCommand: typeof fallbackHistory.agentPromptCommand === 'string' ? fallbackHistory.agentPromptCommand : '',
+        yolo: applied.yolo || '',
+        env: {},
+        envFile: [],
+        volumes: [],
+        ports: []
+    };
+}
+
+function cloneWebAgentSessionsDeep(sourceHistory) {
+    const cloned = {};
+    const agents = sourceHistory && sourceHistory.agents && typeof sourceHistory.agents === 'object'
+        ? sourceHistory.agents
+        : {};
+    Object.keys(agents).forEach(agentId => {
+        cloned[agentId] = JSON.parse(JSON.stringify(agents[agentId]));
+    });
+    return cloned;
+}
+
+async function createClonedContainer(ctx, state, sourceContainerName, requestedName, options = {}) {
+    const copyHistory = options.copyHistory === true;
+    const history = loadWebSessionHistory(state.webHistoryDir, sourceContainerName);
+    const cloneFidelity = history.runtimeSnapshot ? 'full' : 'partial';
+    const createOptions = buildCloneCreateOptionsFromSnapshot(history.runtimeSnapshot, history);
+
+    let finalName = '';
+    if (requestedName) {
+        validateContainerNameStrict(requestedName);
+        const containerMap = listWebManyoyoContainers(ctx);
+        const historyNames = listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName);
+        const taken = new Set([...Object.keys(containerMap), ...historyNames]);
+        if (taken.has(requestedName)) {
+            const err = new Error(`容器名已存在: ${requestedName}`);
+            err.statusCode = 409;
+            throw err;
+        }
+        finalName = requestedName;
+    } else {
+        finalName = resolveUniqueContainerName(ctx, state, sourceContainerName);
+    }
+
+    createOptions.containerName = finalName;
+    const runtime = buildCreateRuntime(ctx, state, { createOptions });
+    await ensureWebContainer(ctx, state, runtime);
+    setWebSessionAgentPromptCommand(state.webHistoryDir, runtime.containerName, runtime.agentPromptCommand);
+
+    const patch = {
+        applied: runtime.applied,
+        runtimeSnapshot: runtime.runtimeSnapshot
+    };
+    if (copyHistory) {
+        patch.agents = cloneWebAgentSessionsDeep(history);
+        patch.agentPromptCommand = history.agentPromptCommand;
+    }
+    patchWebSessionHistory(state.webHistoryDir, finalName, patch);
+
+    return {
+        name: finalName,
+        applied: runtime.applied,
+        sourceContainerName,
+        cloneFidelity,
+        resumeMayFail: copyHistory
+    };
+}
+
+function resolveContainerNamesByHostPath(ctx, state, hostPath) {
+    const target = String(hostPath || '').trim();
+    const containerMap = listWebManyoyoContainers(ctx);
+    const names = new Set([
+        ...Object.keys(containerMap),
+        ...listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName)
+    ]);
+    return Array.from(names).filter(name => {
+        const summary = buildSessionSummary(ctx, state, containerMap, { containerName: name, agentId: WEB_DEFAULT_AGENT_ID });
+        return summary && String(summary.hostPath || '').trim() === target;
+    });
+}
+
 // Estimate container start time from "Up X hours/minutes/seconds" status string.
 // Uses relative time to avoid Podman Machine VM clock drift issues.
 function estimateStartTimeFromStatus(status) {
@@ -3283,6 +3450,8 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef) {
         containerName,
         agentId,
         agentName: agentSession.agentName,
+        agentRemark: agentSession.remark || '',
+        containerRemark: history.remark || '',
         status: containerInfo.status || 'history',
         image: containerInfo.image || '',
         createdAt,
@@ -3924,7 +4093,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 await ensureWebContainer(ctx, state, runtime);
                 setWebSessionAgentPromptCommand(state.webHistoryDir, runtime.containerName, runtime.agentPromptCommand);
                 patchWebSessionHistory(state.webHistoryDir, runtime.containerName, {
-                    applied: runtime.applied
+                    applied: runtime.applied,
+                    runtimeSnapshot: runtime.runtimeSnapshot
                 });
                 sendJson(res, 200, { name: runtime.containerName, applied: runtime.applied });
             }
@@ -3948,6 +4118,125 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/clone-config$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                if (sessionRef.agentId !== WEB_DEFAULT_AGENT_ID) {
+                    sendJson(res, 400, { error: '该操作需在容器层级执行' });
+                    return;
+                }
+                const sourceContainerName = sessionRef.containerName;
+                const historyExists = fs.existsSync(getWebHistoryFile(state.webHistoryDir, sourceContainerName));
+                if (!historyExists && !ctx.containerExists(sourceContainerName)) {
+                    sendJson(res, 404, { error: `容器不存在: ${sourceContainerName}` });
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const requestedName = pickFirstString(payload.containerName);
+                try {
+                    const result = await createClonedContainer(ctx, state, sourceContainerName, requestedName, { copyHistory: false });
+                    sendJson(res, 200, result);
+                } catch (e) {
+                    sendJson(res, e.statusCode || 400, { error: e.message || '创建相同配置容器失败' });
+                }
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/duplicate$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                if (sessionRef.agentId !== WEB_DEFAULT_AGENT_ID) {
+                    sendJson(res, 400, { error: '该操作需在容器层级执行' });
+                    return;
+                }
+                const sourceContainerName = sessionRef.containerName;
+                const historyExists = fs.existsSync(getWebHistoryFile(state.webHistoryDir, sourceContainerName));
+                if (!historyExists && !ctx.containerExists(sourceContainerName)) {
+                    sendJson(res, 404, { error: `容器不存在: ${sourceContainerName}` });
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const requestedName = pickFirstString(payload.containerName);
+                try {
+                    const result = await createClonedContainer(ctx, state, sourceContainerName, requestedName, { copyHistory: true });
+                    sendJson(res, 200, result);
+                } catch (e) {
+                    sendJson(res, e.statusCode || 400, { error: e.message || '复制容器失败' });
+                }
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/container-remark$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                if (sessionRef.agentId !== WEB_DEFAULT_AGENT_ID) {
+                    sendJson(res, 400, { error: '该操作需在容器层级执行' });
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const remark = normalizeRemarkText(payload.remark);
+                patchWebSessionHistory(state.webHistoryDir, sessionRef.containerName, { remark });
+                sendJson(res, 200, { containerName: sessionRef.containerName, remark });
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent-remark$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = await readJsonBody(req);
+                const remark = normalizeRemarkText(payload.remark);
+                patchWebAgentSessionState(state.webHistoryDir, sessionRef, { remark });
+                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), remark });
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath === '/api/sessions/by-directory/remove' ? [] : null,
+            handler: async () => {
+                const payload = await readJsonBody(req);
+                const hostPath = typeof payload.hostPath === 'string' ? payload.hostPath : '';
+                if (!hostPath.trim()) {
+                    sendJson(res, 400, { error: 'hostPath 不能为空' });
+                    return;
+                }
+                const targets = resolveContainerNamesByHostPath(ctx, state, hostPath);
+                if (!targets.length) {
+                    sendJson(res, 404, { error: '未找到该工作目录下的容器' });
+                    return;
+                }
+                const removed = [];
+                const errors = [];
+                targets.forEach(name => {
+                    try {
+                        if (ctx.containerExists(name)) {
+                            ctx.removeContainer(name);
+                        }
+                        removeWebSessionHistory(state.webHistoryDir, name);
+                        removed.push(name);
+                    } catch (e) {
+                        errors.push({ name, error: e.message || String(e) });
+                    }
+                });
+                sendJson(res, 200, { hostPath, removed, errors });
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/messages$/),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "6.2.4",
+    "version": "6.2.6",
     "imageVersion": "1.9.1-common",
     "playwrightCliVersion": "0.1.18",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",