@xcanwin/manyoyo 8.7.3 → 8.7.4

package/lib/web/server.js

@@ -34,6 +34,8 @@ const { domainRuleAllows } = require('../network-policy');
 const { createPortForwarder } = require('../port-forward');
 const { createContainerManageRoutes, pendingRisks, STALE_PAGE_MESSAGE } = require('./container-manage');
 const { createModelServiceRoutes } = require('./model-services');
+const { createJobRegistry, gateRequest } = require('./container-jobs');
+const { createTransferRoutes, createImportContainerFactory } = require('./transfer-routes');
 const { thirdPartyCodexModels } = require('../provider-presets');
 const { resolveManageOptions } = require('../container-manage-options');
 const { defaultPolicy, usesProxy } = require('../network-policy');
@@ -392,6 +394,7 @@ function normalizeWebHistoryRecord(containerName, rawData) {
             applied
         ),
         remark: normalizeRemarkText(data.remark),
+        pinned: data.pinned === true,
         applied,
         // 服务端内部字段，绝不能被 buildSessionSummary/buildSessionDetail/buildSessionAudit 引用或透传给前端。
         runtimeSnapshot,
@@ -3755,6 +3758,68 @@ function buildFirstEnvLines(firstResolved) {
     return lines;
 }
 
+// 容器正在被导出 / 导入时，摘要里带上任务进度（侧栏卡片转圈、刷新页面也看得到）
+function transferJobOf(state, containerName) {
+    const job = state.jobs ? state.jobs.busyFor(containerName) : null;
+    if (!job) return {};
+    const view = job.view();
+    return { job: { id: view.id, type: view.type, stage: view.stage, bytes: view.bytes, estimate: view.estimate } };
+}
+
+// serve 被强杀后重启：恢复被导出任务暂停的容器、撤销没做完的导入（只动记录在案且 manyoyo.id 对得上的）
+function recoverTransferJobs(ctx, state) {
+    try {
+        // 运行时没起来时读不到容器 id，会把“暂停着的容器”误判成已不存在：保留任务记录，下次启动再试
+        try {
+            ctx.dockerExecArgs(['ps', '-a', '-q'], { stdio: 'pipe' });
+        } catch (e) {
+            ctx.logger.warn(`容器运行时暂不可用，跳过导出 / 导入任务的恢复（记录保留，下次启动再试）: ${e.message}`);
+            return;
+        }
+        const reports = state.jobs.recover({
+            containerIdOf: name => resolveContainerId(ctx.dockerExecArgs, name),
+            isPaused: name => {
+                try {
+                    return /paused/i.test(String(ctx.dockerExecArgs(['inspect', '-f', '{{.State.Status}}', name], { stdio: 'pipe' }) || ''));
+                } catch (e) {
+                    return false;
+                }
+            },
+            unpause: name => ctx.dockerExecArgs(['unpause', name], { stdio: 'pipe' }),
+            isStopped: name => {
+                try {
+                    return /exited|stopped|created/i.test(String(ctx.dockerExecArgs(['inspect', '-f', '{{.State.Status}}', name], { stdio: 'pipe' }) || ''));
+                } catch (e) {
+                    return false;
+                }
+            },
+            start: name => ctx.dockerExecArgs(['start', name], { stdio: 'pipe' }),
+            removeContainer: name => removeContainerIdempotent(ctx, name),
+            removePath: target => fs.rmSync(target, { recursive: true, force: true })
+        });
+        reports.forEach(report => ctx.logger.warn(`上次的${report.type === 'export' ? '导出' : '导入'}任务被中断，已恢复：${JSON.stringify({ restored: report.restored, removed: report.removed.length })}`));
+    } catch (e) {
+        ctx.logger.warn(`恢复导出 / 导入任务失败: ${e.message}`);
+    }
+}
+
+function pickPluginRunConfig(runConfig) {
+    const picked = {};
+    ['plugins', 'imageName', 'imageVersion'].forEach(key => {
+        if (runConfig && hasOwn(runConfig, key)) picked[key] = runConfig[key];
+    });
+    return picked;
+}
+
+// 按快照重建 / 复制容器时没有 run 参数：按快照里记的运行配置名现读当前配置，配置已删除就当没有
+function pluginRunConfigOfSnapshot(state, snapshot) {
+    const runName = snapshot && typeof snapshot.run === 'string' ? snapshot.run : '';
+    if (!runName) return {};
+    const parsed = readWebConfigSnapshot(state.webConfigPath);
+    const runs = toPlainObject(parsed.parseError ? {} : (parsed.parsed || {}).runs);
+    return hasOwn(runs, runName) ? pickPluginRunConfig(toPlainObject(runs[runName])) : {};
+}
+
 function buildCreateRuntime(ctx, state, payload) {
     const body = toPlainObject(payload);
     const requestOptions = toPlainObject(body.createOptions);
@@ -3762,7 +3827,11 @@ function buildCreateRuntime(ctx, state, payload) {
     const config = snapshot.parseError ? {} : snapshot.parsed;
     const runs = toPlainObject(config.runs);
     const runName = pickFirstString(body.run);
-    const runConfig = runName && hasOwn(runs, runName) ? toPlainObject(runs[runName]) : {};
+    // 与 CLI 一致：指定了不存在的运行配置就报错，不悄悄退回全局默认配置
+    if (runName && !hasOwn(runs, runName)) {
+        throw new Error(`未找到运行配置: runs.${runName}`);
+    }
+    const runConfig = runName ? toPlainObject(runs[runName]) : {};
 
     const hasRequestEnv = hasOwn(requestOptions, 'env');
     const hasRequestEnvFile = hasOwn(requestOptions, 'envFile');
@@ -3847,6 +3916,13 @@ function buildCreateRuntime(ctx, state, payload) {
 
     const containerName = resolvedBase.containerName;
     validateContainerNameStrict(containerName);
+    // 名字被正在进行的导入占着（预留）：别处不能同名新建，只有导入自己建容器时放行
+    if (payload.allowReservedName !== true && state.jobs && state.jobs.busyFor(containerName)) {
+        const busy = state.jobs.busyFor(containerName);
+        const err = new Error(busy.type === 'import' ? `容器名 ${containerName} 正被导入使用，请换一个名字` : `容器 ${containerName} 正在导出，完成后可用`);
+        err.statusCode = 409;
+        throw err;
+    }
 
     const hostPath = resolvedBase.hostPath;
     // 按模板（{now} / {quickChatPath}）生成的目录：此刻才建
@@ -3973,6 +4049,8 @@ function buildCreateRuntime(ctx, state, payload) {
         imageVersion,
         contModeArgs,
         containerExtraArgs: Array.isArray(ctx.containerExtraArgs) ? ctx.containerExtraArgs.slice() : [],
+        // 只给 Playwright 插件用（runs.<名>.plugins.playwright 与 vnc 模式用的镜像），不进快照和任何响应
+        pluginRunConfig: pickPluginRunConfig(runConfig),
         containerEnvs,
         envFiles,
         first: firstCommand ? { command: firstCommand, envLines: buildFirstEnvLines(firstResolved) } : null,
@@ -4153,6 +4231,7 @@ async function createClonedContainer(ctx, state, sourceContainerName, requestedN
 
     createOptions.containerName = finalName;
     const runtime = buildCreateRuntime(ctx, state, { createOptions });
+    runtime.pluginRunConfig = pluginRunConfigOfSnapshot(state, history.runtimeSnapshot);
     await ensureWebContainer(ctx, state, runtime);
     setWebSessionAgentPromptCommand(state.webHistoryDir, runtime.containerName, runtime.agentPromptCommand);
 
@@ -4233,6 +4312,7 @@ function listWebManyoyoContainers(ctx) {
     // 历史 JSON（见 buildSessionSummary 的 preloadedHistory 注释）。排查这条路径
     // 变慢时别先怀疑 docker/podman。
     const defaultCommandByName = {};
+    const createdByName = {};
     if (candidates.length) {
         let inspectOutput = '';
         try {
@@ -4241,7 +4321,7 @@ function listWebManyoyoContainers(ctx) {
                     [
                         'inspect',
                         '-f',
-                        '{{.Name}}\t{{index .Config.Labels "manyoyo.default_cmd"}}',
+                        '{{.Name}}\t{{index .Config.Labels "manyoyo.default_cmd"}}\t{{.Created}}',
                         ...candidates.map(c => c.name)
                     ],
                     { ignoreError: true }
@@ -4251,11 +4331,14 @@ function listWebManyoyoContainers(ctx) {
             inspectOutput = '';
         }
         inspectOutput.split('\n').forEach(line => {
-            const [rawName, defaultCommand] = line.split('\t');
+            const [rawName, defaultCommand, created] = line.split('\t');
             if (!rawName) {
                 return;
             }
-            defaultCommandByName[rawName.replace(/^\//, '')] = (defaultCommand || '').trim();
+            const key = rawName.replace(/^\//, '');
+            defaultCommandByName[key] = (defaultCommand || '').trim();
+            const time = new Date(String(created || '').trim());
+            if (!Number.isNaN(time.getTime())) createdByName[key] = time.toISOString();
         });
     }
 
@@ -4265,6 +4348,8 @@ function listWebManyoyoContainers(ctx) {
             status: status || 'unknown',
             image: imageName,
             createdAt: estimateStartTimeFromStatus(status),
+            // 容器真正的创建时间（inspect 的 Created），排序用；createdAt 是从“Up 3 hours”估的启动时间
+            containerCreatedAt: createdByName[name] || null,
             defaultCommand: defaultCommandByName[name] || ''
         };
     });
@@ -4543,6 +4628,7 @@ async function buildWebPlaywrightIntegration(ctx, state, runtime) {
     }
     const integration = await buildContainerIntegration({
         globalConfig,
+        runConfig: runtime.pluginRunConfig || {},
         homeDir: ctx.homeDir,
         runtimeCommand: ctx.dockerCmd || 'docker',
         envEntries: (runtime.containerEnvs || []).filter((_, i) => i % 2 === 1)
@@ -4585,7 +4671,9 @@ function resolveRuntimeForExistingName(ctx, state, containerName) {
     }
     const createOptions = buildCloneCreateOptionsFromSnapshot(snapshot, history);
     createOptions.containerName = containerName;
-    return buildCreateRuntime(ctx, state, { createOptions });
+    const runtime = buildCreateRuntime(ctx, state, { createOptions });
+    runtime.pluginRunConfig = pluginRunConfigOfSnapshot(state, snapshot);
+    return runtime;
 }
 
 async function ensureWebContainer(ctx, state, containerInput, messageSessionRef = null) {
@@ -6666,6 +6754,9 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef, preloadedHist
         firstPrompt: agentSession.firstPrompt || '',
         pinned: agentSession.pinned === true,
         containerRemark: history.remark || '',
+        ...(transferJobOf(state, containerName)),
+        containerPinned: history.pinned === true,
+        containerCreatedAt: containerInfo.containerCreatedAt || null,
         status: containerInfo.status || 'history',
         image: containerInfo.image || '',
         createdAt,
@@ -7331,6 +7422,17 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             return true;
         }
     }
+    // 导出 / 导入期间，这些容器的聊天、终端、文件、设置、删除一律 409（只放行读消息和详情）
+    // 清理历史 / 工作目录的接口不带容器名：有任务在跑就一律拒绝（可能删掉正在导出的历史或刚建好的导入目录）
+    if (state.jobs && state.jobs.hasRunning() && req.method !== 'GET' && req.method !== 'HEAD' && pathname.startsWith('/api/storage/')) {
+        sendJson(res, 409, { error: '正在导出或导入，完成后再清理', busy: 'transfer' });
+        return true;
+    }
+    const gateVerdict = state.jobs ? gateRequest(state.jobs, req.method, pathname) : null;
+    if (gateVerdict) {
+        sendJson(res, gateVerdict.status, gateVerdict.body);
+        return true;
+    }
     const routes = [
         {
             method: 'GET',
@@ -7883,6 +7985,14 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     sendJson(res, 400, { error: 'run 不能为空' });
                     return;
                 }
+                {
+                    const configSnapshot = readWebConfigSnapshot(state.webConfigPath);
+                    const knownRuns = toPlainObject(configSnapshot.parseError ? {} : (configSnapshot.parsed || {}).runs);
+                    if (!hasOwn(knownRuns, quickChatRun)) {
+                        sendJson(res, 400, { error: `未找到运行配置: runs.${quickChatRun}` });
+                        return;
+                    }
+                }
                 const resolvedPath = expandHomeAliasPath(quickChatPath);
                 const homeDir = process.env.HOME || os.homedir() || '/home';
                 if (resolvedPath === '/' || resolvedPath === homeDir) {
@@ -7945,7 +8055,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 try {
                     runtime = buildCreateRuntime(ctx, state, payload);
                 } catch (e) {
-                    sendJson(res, 400, { error: e.message || '创建参数错误' });
+                    sendJson(res, e.statusCode || 400, { error: e.message || '创建参数错误' });
                     return;
                 }
 
@@ -8051,6 +8161,24 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 sendJson(res, 200, { containerName: sessionRef.containerName, remark });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/container-pin$/),
+            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 pinned = payload.pinned === true;
+                patchWebSessionHistory(state.webHistoryDir, sessionRef.containerName, { pinned });
+                sendJson(res, 200, { containerName: sessionRef.containerName, pinned });
+            }
+        },
         {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent-remark$/),
@@ -9479,6 +9607,63 @@ async function handleWebApi(req, res, pathname, ctx, state) {
         }
     }));
 
+    routes.push(...createTransferRoutes({
+        ctx,
+        state,
+        req,
+        res,
+        deps: {
+            sendJson,
+            readJsonBody,
+            containerState,
+            version: require('../../package.json').version,
+            loadHistory: name => loadWebSessionHistory(state.webHistoryDir, name),
+            historyExists: name => listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName).includes(name),
+            listContainerNames: () => Object.keys(listWebManyoyoContainers(ctx)),
+            listHistoryNames: () => listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName),
+            quickChatPath: () => {
+                const snapshot = readWebConfigSnapshot(state.webConfigPath);
+                return resolveQuickChatPath(snapshot.parseError ? {} : snapshot.parsed, { homeDir: ctx.homeDir || os.homedir(), defaultDir: getSetupWorkpath(state) });
+            },
+            createImportedContainer: createImportContainerFactory({
+                ctx,
+                state,
+                buildCreateRuntime,
+                ensureWebContainer,
+                resolveContainerId,
+                containerState,
+                patchHistory: (name, patch) => patchWebSessionHistory(state.webHistoryDir, name, patch)
+            }),
+            removeCreatedContainer: async (name, id) => {
+                if (resolveContainerId(ctx.dockerExecArgs, name) === id) removeContainerIdempotent(ctx, name);
+                removeWebSessionHistory(state.webHistoryDir, name);
+            },
+            saveImportedHistory: async (name, archived, info) => {
+                const current = loadWebSessionHistory(state.webHistoryDir, name);
+                const source = normalizeWebHistoryRecord(name, archived);
+                const agents = cloneWebAgentSessionsDeep(source);
+                Object.values(agents).forEach(agent => {
+                    // 没带 Agent 会话记录时不能留着续接标记：服务端不检查会话文件在不在，第一轮必定失败
+                    if (!info.hasSessions) {
+                        agent.engineSessionId = '';
+                        agent.lastResumeAt = null;
+                        agent.lastResumeOk = null;
+                        agent.lastResumeError = '';
+                    }
+                    // 导入前排着的提示词不要在新环境里自己跑起来
+                    if (Array.isArray(agent.queue) && agent.queue.length) agent.queuePaused = true;
+                });
+                saveWebSessionHistory(state.webHistoryDir, name, {
+                    ...current,
+                    // 导入时用户填了备注就用它（空串表示清掉），没填沿用归档里的
+                    remark: typeof info.remark === 'string' ? normalizeRemarkText(info.remark) : source.remark,
+                    pinned: source.pinned,
+                    agents
+                });
+            }
+        }
+    }));
+
     routes.push(...createContainerManageRoutes({
         ctx,
         state,
@@ -9553,6 +9738,9 @@ async function startWebServer(options) {
         containerExtraArgs: options.containerExtraArgs,
         containerEnvs: options.containerEnvs,
         networkManager: options.networkManager,
+        // 导出 / 导入用的容器运行时封装（默认走命令行 docker / podman），测试里可替换
+        transferRuntime: options.transferRuntime,
+        statfsSync: options.statfsSync,
         envFiles: options.envFiles,
         containerVolumes: options.containerVolumes,
         containerPorts: options.containerPorts,
@@ -9613,6 +9801,7 @@ async function startWebServer(options) {
             warn: message => ctx.logger.warn(message)
         }),
         terminalSessions: new Map(),
+        jobs: createJobRegistry({ homeDir: ctx.homeDir || os.homedir() }),
         agentRuns: new Map(),
         // imageRef -> { status: 'pulling'|'failed', message, promise }
         imagePulls: new Map(),
@@ -9620,6 +9809,16 @@ async function startWebServer(options) {
     };
 
     ensureWebHistoryDir(state.webHistoryDir);
+    recoverTransferJobs(ctx, state);
+    // 进程正常退出（SIGTERM / SIGINT 走 process.exit）时同步恢复被导出任务暂停的容器；被强杀的由下次启动的 recoverTransferJobs 兜底
+    const unpauseOnExit = () => {
+        for (const job of state.jobs.running()) {
+            for (const item of job.paused.slice()) {
+                try { ctx.dockerExecArgs([item.how === 'stop' ? 'start' : 'unpause', item.name], { stdio: 'pipe' }); } catch (e) { /* 下次启动恢复 */ }
+            }
+        }
+    };
+    process.on('exit', unpauseOnExit);
 
     const wsServer = new WebSocket.Server({
         noServer: true,
@@ -9639,7 +9838,9 @@ async function startWebServer(options) {
         bindTerminalWebSocket(ctx, state, ws, containerName, cols, rows);
     });
 
-    const server = http.createServer(async (req, res) => {
+    // 导入是一次很长的上传请求：Node 默认 300 秒的整请求超时会把慢链路上的大文件截断。
+    // 请求头仍受 headersTimeout 约束；未登录的请求在读完请求头后立刻 401，不会占着连接等请求体
+    const server = http.createServer({ requestTimeout: 0 }, async (req, res) => {
         // 身份标记：无参启动器复用实例前用它确认端口上跑的确实是 manyoyo serve（未登录的 401 也带）；不含任何版本或本机信息
         res.setHeader('X-Manyoyo-Serve', '1');
         try {
@@ -9762,6 +9963,11 @@ async function startWebServer(options) {
             return;
         }
 
+        if (state.jobs.busyFor(sessionRef.containerName)) {
+            sendWebSocketUpgradeError(socket, 409, 'BUSY_EXPORT_IMPORT');
+            return;
+        }
+
         if (state.terminalSessions.size >= WEB_TERMINAL_MAX_SESSIONS) {
             sendWebSocketUpgradeError(socket, 429, 'TERMINAL_LIMIT_REACHED');
             return;
@@ -9842,6 +10048,9 @@ async function startWebServer(options) {
         port: listenPort,
         close: () => new Promise(resolve => {
             ctx.logger.info('web server closing');
+            process.removeListener('exit', unpauseOnExit);
+            // 关服务时取消还在跑的导出 / 导入任务（导出会在取消时恢复暂停的容器）
+            state.jobs.running().forEach(job => { job.cancelRequested = true; });
             flushWebSessionHistories();
             state.authStore.close();
             state.orphanTimers.forEach(timer => clearInterval(timer));