Files
agent/executor/server.js
T
2026-09-11 19:40:07 +08:00

665 lines
31 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// agent-executor:命令执行服务(独立容器,供 agent-core 调用)。单文件零依赖,仅用 Node 内置 http,默认端口 9000。
//
// 接口:
// GET /health → {ok, time}
// POST /exec body {command, cwd?, timeout_ms?, max_output_chars?, env?}
// 响应 SSE:{"type":"start"|"out"|"err"|"exit", ...};期间每 15s 发 ": ping"
// DELETE /exec/:id → {ok:true} 杀整个进程组
//
// 安全模型(v4):
// 1. 宿主机 ./tasks 挂载到 ISOLATION_BASE(默认 /mnt/host-tasks),该路径【永不在 ROOTS 内】。
// 2. 每条 /exec 命令都在 unshare --mount --pid --fork --propagation private 的新 mount
// namespace 中运行,不存在“非隔离模式”——杜绝“换个 cwd 就绕过卸载”的降级旁路。
// 3. wrapper 进 ns 后:先把当前 session bind 到私有 tmpfs 上的 anchor 保命,随后用一层
// 空 tmpfs【遮盖】整个 /mnt(含 ISOLATION_BASE)。之后 AI 无论从哪条路径探测都拿不到
// 其它 session 的数据。
//
// ⚠️ 关键教训(v4 曾因此把数据卷从父 ns 卸掉,导致服务半死):
// 绝对不要在子 ns 里对 ISOLATION_BASE 执行 umount。Docker 容器根 mount table 默认是
// shared,`unshare --propagation private` 并不可靠地阻断 umount 的反向传播,一旦泄漏
// 父 ns 就永久失去该挂载(只能重启容器恢复)。遮盖(mount over)是本 ns 局部操作,
// 不改动原挂载条目,ns 销毁即无痕,才是安全做法。
// 4. /tmp、anchor 目录、scratch 都是 per-session 私有 tmpfs,跨会话不可见,崩溃残留随 ns 消失。
// 5. 只用 POSIX sh 兼容语法(镜像默认 dash):不使用 trap ERR、不使用 bash 数组/[[ ]]。
// 隔离层自身失败以退出码 90-99 回传,便于与 AI 命令的失败区分。
// 6. DEFAULT_CWD / SCRATCH_ROOT 在父 ns 中必须是【存在的空目录】(由 Dockerfile 预建):
// 存在才能当挂载点,为空才不会成为数据旁路。selfCheck 会校验这两点。
//
// 约束:
// - 设置 EXECUTOR_TOKEN 后除 /health 外必须带 Authorization: Bearer <token>;
// - cwd 必须落在 EXECUTOR_ROOTS(逗号分隔白名单)内,且不得是任务根本身;
// - session 目录及其链上不得含符号链接(防解析后逃逸);
// - timeout_ms 夹在 [1s, EXECUTOR_MAX_TIMEOUT_MS];stdout/stderr 各自按 max_output_chars 截断。
//
// 日志:EXECUTOR_LOG_LEVEL=debug|info|warn|error|none
'use strict';
const http = require('http');
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const { spawn } = require('child_process');
// ---------- 配置 ----------
const PORT = parseInt(process.env.PORT, 10) || 9000;
const TOKEN = process.env.EXECUTOR_TOKEN || '';
const ROOTS = (process.env.EXECUTOR_ROOTS || '/workspace')
.split(',').map(s => s.trim()).filter(Boolean).map(p => path.resolve(p));
// 隔离基路径:宿主机 tasks 在本容器内的真实挂载点。wrapper 用空 tmpfs 遮盖它的父目录来隐藏。
const ISOLATION_BASE = path.resolve(process.env.EXECUTOR_ISOLATION_BASE || '/mnt/host-tasks');
// 虚拟任务根:AI 看到的 tasks 路径,仅在子 ns 中由 wrapper 构造。
const DEFAULT_CWD = path.resolve(process.env.EXECUTOR_CWD || path.join(ROOTS[0], 'tasks'));
// 每个会话私有的空工作区根(不给任何真实数据)。必须与 DEFAULT_CWD 平级,不能在其之下。
const SCRATCH_ROOT = path.resolve(process.env.EXECUTOR_SCRATCH_ROOT || path.join(ROOTS[0], 'scratch'));
// 技能目录:期望由 compose 以 :ro 挂载。
const SKILLS_DIR = path.resolve(process.env.EXECUTOR_SKILLS_DIR || path.join(ROOTS[0], 'skills'));
// server.js 所在目录(镜像 WORKDIR /app):用 tmpfs 盖住,不让 AI 读 executor 源码。
const APP_DIR = path.resolve(__dirname);
const MAX_TIMEOUT = parseInt(process.env.EXECUTOR_MAX_TIMEOUT_MS, 10) || 30 * 60 * 1000;
const DEFAULT_MAX_OUT = parseInt(process.env.EXECUTOR_MAX_OUTPUT_CHARS, 10) || 200000;
const PING_MS = 15000;
const BODY_LIMIT = 1024 * 1024;
const runs = new Map(); // id -> { child, killedBy, started_at, cwd, timer }
// ---------- 小工具 ----------
function isUnder(p, root) { return p === root || p.startsWith(root + path.sep); }
function shq(s) { return "'" + String(s).replace(/'/g, "'\\''") + "'"; }
function brief(s, n) {
s = String(s); n = n || 2000;
return s.length > n ? s.slice(0, n) + '…(+' + (s.length - n) + ')' : s;
}
// ---------- 分级日志 ----------
const LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
function parseLevel(l) {
const s = String(l || 'info').trim().toLowerCase();
if (s === 'none' || s === 'off') return Infinity;
return LEVELS[s] == null ? LEVELS.info : LEVELS[s];
}
const LOG_LEVEL = parseLevel(process.env.EXECUTOR_LOG_LEVEL);
const pad = (n, w) => String(n).padStart(w || 2, '0');
function stamp() {
const d = new Date();
return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()) + ' ' +
pad(d.getHours()) + ':' + pad(d.getMinutes()) + ':' + pad(d.getSeconds()) + '.' + pad(d.getMilliseconds(), 3);
}
function emit(fn, level, args) {
if (LEVELS[level] < LOG_LEVEL) return;
const rest = Array.prototype.slice.call(args);
const head = stamp() + ' [' + level + '] [executor]';
if (typeof rest[0] === 'string') rest[0] = head + ' ' + rest[0];
else rest.unshift(head);
fn.apply(console, rest);
}
const log = {
debug() { emit(console.log, 'debug', arguments); },
info() { emit(console.log, 'info', arguments); },
warn() { emit(console.warn, 'warn', arguments); },
error() { emit(console.error, 'error', arguments); },
};
// 目录是否为“存在且为空”(允许作为安全的 tmpfs 挂载点)
function emptyDirState(p) {
let st = null;
try { st = fs.statSync(p); } catch (_) { return 'missing'; }
if (!st.isDirectory()) return 'not_dir';
let ents = [];
try { ents = fs.readdirSync(p); } catch (_) { return 'unreadable'; }
return ents.length === 0 ? 'empty' : 'nonempty';
}
// ---------- 启动自检 ----------
function selfCheck() {
const problems = [];
const warns = [];
for (const r of ROOTS) {
if (isUnder(ISOLATION_BASE, r)) {
problems.push('ISOLATION_BASE=' + ISOLATION_BASE + ' 落在 ROOTS(' + r + ') 内,AI 可访问未卸载的基路径');
}
if (isUnder(r, ISOLATION_BASE)) {
problems.push('ROOTS(' + r + ') 位于 ISOLATION_BASE 之下');
}
}
let bs = null;
try { bs = fs.statSync(ISOLATION_BASE); } catch (_) {}
if (!bs || !bs.isDirectory()) {
problems.push('ISOLATION_BASE=' + ISOLATION_BASE + ' 不存在或不是目录 —— compose 的 volumes 没挂到这里?');
} else if (fs.readdirSync(ISOLATION_BASE).length === 0) {
// v4 事故特征:挂载被 wrapper 误卸后,此处会变成一个空目录且 /proc/mounts 里无条目。
problems.push('ISOLATION_BASE=' + ISOLATION_BASE + ' 为空 —— 数据卷可能被卸载(检查 /proc/mounts),需重建容器恢复');
}
// 确保基路径确实是一个独立挂载点;不是的话说明它只是普通目录,遮盖将无效。
let mounted = false;
try {
const mt = fs.readFileSync('/proc/mounts', 'utf8').split('\n');
const esc = ISOLATION_BASE.replace(/ /g, '\\040');
for (const line of mt) {
const parts = line.split(' ');
if (parts[1] === esc) { mounted = true; break; }
}
} catch (_) {}
if (!mounted && bs && bs.isDirectory()) {
problems.push('ISOLATION_BASE=' + ISOLATION_BASE + ' 不是挂载点 —— 无法确定它是宿主机数据卷');
}
// 防“盖到自己头上”:MNTROOT(遮盖目标)不能落在 ROOTS 内,否则会把合法工作区一并封死。
const MNTROOT = path.parse(ISOLATION_BASE).dir || '/';
for (const r of ROOTS) {
if (isUnder(r, MNTROOT) || r === MNTROOT) {
problems.push('MNTROOT=' + MNTROOT + ' 包含或等于 ROOTS(' + r + '),遮盖会连带封死合法工作区');
}
}
// 虚拟任务根必须是“存在的空目录”:存在才能当 tmpfs 挂载点,为空才不是数据旁路。
const dcs = emptyDirState(DEFAULT_CWD);
if (dcs === 'missing') {
warns.push('DEFAULT_CWD=' + DEFAULT_CWD + ' 不存在(wrapper 会自动 mkdir,但建议 Dockerfile 预建)');
} else if (dcs !== 'empty') {
problems.push('DEFAULT_CWD=' + DEFAULT_CWD + ' 在父 ns 中非空/异常(' + dcs + ') —— 请确认没有把 ./tasks 挂到该路径');
}
const scs = emptyDirState(SCRATCH_ROOT);
if (scs === 'missing') {
warns.push('SCRATCH_ROOT=' + SCRATCH_ROOT + ' 不存在(wrapper 会自动 mkdir,但建议 Dockerfile 预建)');
} else if (scs !== 'empty') {
problems.push('SCRATCH_ROOT=' + SCRATCH_ROOT + ' 在父 ns 中非空/异常(' + scs + ')');
}
if (isUnder(SCRATCH_ROOT, DEFAULT_CWD)) {
problems.push('SCRATCH_ROOT=' + SCRATCH_ROOT + ' 位于 DEFAULT_CWD 之下,会被 tmpfs 遮盖连带抹掉');
}
if (isUnder(DEFAULT_CWD, SCRATCH_ROOT)) {
problems.push('DEFAULT_CWD=' + DEFAULT_CWD + ' 位于 SCRATCH_ROOT 之下,两者遮盖顺序冲突');
}
let ss = null;
try { ss = fs.statSync(SKILLS_DIR); } catch (_) {}
if (!ss) warns.push('SKILLS_DIR=' + SKILLS_DIR + ' 不存在(若不使用技能可忽略)');
if (problems.length) log.error('启动自检失败:\n - ' + problems.join('\n - '));
else if (warns.length) log.warn('启动自检通过(有提示):\n - ' + warns.join('\n - '));
else log.info('启动自检通过');
return problems.length === 0;
}
// ---------- 隔离脚本生成 ----------
// 全部为 POSIX sh 兼容语句;任一步失败由显式退出码标注(90-99 = 隔离层故障)。
// 铁律:本函数内不得出现任何对 ISOLATION_BASE / MNTROOT 的 umount。只允许 mount(遮盖)。
// 诊断原则:成功路径零输出;只在失败分支里附带最小现场信息(不报 session 名、不报内容)。
function buildIsolation(command, plan) {
const L = [];
L.push('set -e');
// --- 传播属性:确保本 ns 的挂载变更不向对等组回传(多一重保险)---
L.push('mount --make-rprivate / 2>/dev/null || true');
// (诊断输出改为“只在失败分支里印”,见下方 anchor / mask 等步骤;
// 原因:无条件输出会污染每条命令的 stderr,且 entries 计数会泄露会话规模。)
// --- proc 加固:只读 + 敏感项顶掉 ---
L.push('mount -t proc -o nosuid,noexec,nodev proc /proc || { echo "[isolate] proc failed" >&2; exit 90; }');
L.push('for f in kcore keys kmsg sysrq-trigger sched_debug; do if [ -e /proc/$f ]; then mount --bind /dev/null /proc/$f 2>/dev/null || true; fi; done');
L.push('mount --bind /proc/sys /proc/sys 2>/dev/null || true');
L.push('mount -o remount,bind,ro /proc/sys 2>/dev/null || true');
// --- 遮盖 executor 自身代码目录(与工作区无父子关系时才做)---
if (!(isUnder(DEFAULT_CWD, APP_DIR) || isUnder(APP_DIR, DEFAULT_CWD))) {
L.push('mount -t tmpfs tmpfs ' + shq(APP_DIR) + ' || { echo "[isolate] hide appdir failed" >&2; exit 91; }');
}
// --- 本会话私有 tmpfs:/tmp 与 anchor 目录 ---
L.push('mkdir -p /tmp');
L.push('mount -t tmpfs -o nosuid,nodev,mode=1777 tmpfs /tmp || { echo "[isolate] /tmp failed" >&2; exit 92; }');
L.push('RUNDIR=/run/agent-exec');
L.push('mkdir -p "$RUNDIR"');
L.push('mount -t tmpfs -o nosuid,nodev,mode=700 tmpfs "$RUNDIR" || { echo "[isolate] rundir failed" >&2; exit 93; }');
// --- 数据面 ---
if (plan.mode === 'session') {
// 1) 【必须最先做】把真实 session 目录 bind 到本会话私有 tmpfs($RUNDIR) 上的 anchor。
// 这一步在任何遮盖发生之前完成,拿到一份不依赖原路径的独立引用。
L.push('ANCH=$(mktemp -d "$RUNDIR/a.XXXXXXXX")');
// 失败时才采集现场:base_entries=0 即“数据卷被摘”特征(v4 事故),无需在正常路径上付费。
L.push('mount --bind ' + shq(plan.realSession) + ' "$ANCH" || { _b=N; if [ -d "' + ISOLATION_BASE + '" ]; then _b=Y; fi; echo "[isolate] anchor failed base=${_b}" >&2; exit 94; }');
// 2) 【核心】用空只读 tmpfs 遮盖整个 /mnt(ISOLATION_BASE 的父目录),使基路径及其下
// 所有 session 对本 ns 不可见。只做 mount,永远不做 umount —— umount 可能传播回
// 父 ns 并永久摘掉数据卷(v4 事故)。遮盖是本 ns 局部操作,ns 销毁即无痕。
L.push('MNTROOT=' + shq(path.parse(ISOLATION_BASE).dir || '/'));
L.push('mkdir -p "$MNTROOT"');
L.push('mount -t tmpfs -o ro,size=0 tmpfs "$MNTROOT" || { echo "[isolate] mask mnt failed" >&2; exit 98; }');
// 3) 重建虚拟视图:先盖住任务根,再把 anchor 内容 bind 回本 session 的虚拟路径
L.push('mkdir -p ' + shq(DEFAULT_CWD));
L.push('mount -t tmpfs -o nosuid,nodev tmpfs ' + shq(DEFAULT_CWD) + ' || { echo "[isolate] mask tasks failed" >&2; exit 95; }');
L.push('mkdir -p ' + shq(plan.virtSession));
// 虚拟 cwd 可能在 session 之下更深处(校验时按“缺失即交给这里建”处理)。
// 必须先 bind 再建:深层目录建在 tmpfs 遮盖层上会在 rebind 时被本会话数据盖掉;
// 而 mkdir 在已 bind 的 virtSession 下建新子目录只发生在本 ns,不会写穿到宿主盘。
L.push('mount --bind "$ANCH" ' + shq(plan.virtSession) + ' || { echo "[isolate] rebind failed" >&2; exit 96; }');
L.push('mkdir -p ' + shq(plan.cwd));
// 4) 释放锚点目录项(仅本 ns 私有的 $RUNDIR 内,可安全卸载)
// 数据仍通过 virtSession 的 bind 存活,ns 退出时彻底回收。
L.push('umount -l "$ANCH" 2>/dev/null || true');
L.push('rmdir "$ANCH" 2>/dev/null || true');
} else {
// scratch / plain:不需要任何真实数据,直接遮盖基路径即可
L.push('MNTROOT=' + shq(path.parse(ISOLATION_BASE).dir || '/'));
L.push('mkdir -p "$MNTROOT"');
L.push('mount -t tmpfs -o ro,size=0 tmpfs "$MNTROOT" || { echo "[isolate] mask mnt failed" >&2; exit 98; }');
if (plan.mode === 'scratch') {
L.push('mkdir -p ' + shq(SCRATCH_ROOT));
L.push('mount -t tmpfs -o nosuid,nodev tmpfs ' + shq(SCRATCH_ROOT) + ' || { echo "[isolate] scratch failed" >&2; exit 95; }');
// 同 session 分支:建到遮盖后的 SCRATCH_ROOT 之下,覆盖 plan.cwd 的全部深度
L.push('mkdir -p ' + shq(plan.cwd));
}
// plain(典型:只读的 skills):只需上面的 /mnt 遮盖
}
// --- 进入目标目录并执行 ---
L.push('cd ' + shq(plan.cwd) + ' || { echo "[isolate] cd failed" >&2; exit 97; }');
L.push('exec /bin/sh -c ' + shq(command));
return L.join('\n');
}
// ---------- 运行期健康护栏 ----------
// v4 事故后加:如果基路径在运行中被(错误地)卸载,所有后续请求都会变成
// “session 不存在”的静默半死状态。这里连续失败到阈值就打 error,提醒运维。
let consecutiveSessionMiss = 0;
function noteSessionProbe(ok) {
if (ok) { consecutiveSessionMiss = 0; return; }
consecutiveSessionMiss += 1;
if (consecutiveSessionMiss === 5 || consecutiveSessionMiss % 20 === 0) {
log.error('ISOLATION_BASE=' + ISOLATION_BASE + ' 已连续 ' + consecutiveSessionMiss +
' 次无法访问 session 目录 —— 数据卷很可能已被卸载。' +
'确认方法: docker exec agent-executor grep host-tasks /proc/mounts;' +
'恢复方法: docker compose up -d --force-recreate agent-executor');
}
}
// ---------- cwd 校验与隔离计划 ----------
function resolveCwd(raw) {
let cwd;
try { cwd = path.resolve(String(raw || '')); } catch (_) { return { ok: false, reason: 'cwd 无法解析' }; }
if (!cwd.startsWith(path.sep)) return { ok: false, reason: 'cwd 必须是绝对路径' };
// 1) 白名单
if (!ROOTS.some(r => isUnder(cwd, r))) return { ok: false, reason: 'not_in_roots' };
// 2) 基路径永远不允许(纵深防御,万一 ROOTS 配错)
if (isUnder(cwd, ISOLATION_BASE) || isUnder(ISOLATION_BASE, cwd)) {
return { ok: false, reason: 'isolation_base_forbidden' };
}
// 3) 禁止在根本身执行
if (cwd === DEFAULT_CWD || cwd === SCRATCH_ROOT) return { ok: false, reason: 'cwd 不能是任务根本身' };
// 4) 路径段合法性(统一拦截 .. / 空段 / NUL)
// 注意:必须在 resolveCwd 入口处对“原始字符串”检查 —— path.resolve 会提前折叠掉 ..,
// 若在归一化之后才查就永远查不到。AI 无法预知 session 名,把 .. 拼进 session 段
// (如 <sid>/../sessB)是唯一途径,在原始串上拦即可封死跨 session 借道。
{
const rawStr = String(raw || '');
if (rawStr.indexOf('\0') >= 0) return { ok: false, reason: '非法字符' };
for (const s of rawStr.split('/')) {
if (s === '..') return { ok: false, reason: '非法路径段' };
}
}
for (const s of cwd.split(path.sep)) {
if (s === '..') return { ok: false, reason: '非法路径段' };
}
// 5) session 路径:虚拟视图在父 ns 不存在属正常,故不做 lstat,改校验其映射的真实路径
const relFromTasks = path.relative(DEFAULT_CWD, cwd);
const isSessionPath = relFromTasks !== '' && !relFromTasks.startsWith('..' + path.sep) && !path.isAbsolute(relFromTasks) && relFromTasks !== '..';
if (isSessionPath) {
const sessionName = relFromTasks.split(path.sep)[0];
if (!sessionName || sessionName === '.' || sessionName === '..') {
return { ok: false, reason: '非法 session 名' };
}
const realSession = path.join(ISOLATION_BASE, sessionName);
let rs;
try { rs = fs.lstatSync(realSession); } catch (_) {
noteSessionProbe(false);
return { ok: false, reason: 'session 不存在' };
}
noteSessionProbe(true);
if (rs.isSymbolicLink()) return { ok: false, reason: 'session 不得是符号链接' };
if (!rs.isDirectory()) return { ok: false, reason: 'session 不是目录' };
// session 之下必须逐级是真实目录(不得文件/符号链接);缺失的深层路径按存在处理,
// 交给 wrapper 在子 ns 内 mkdir -p —— 它只会建在本会话 bind 里,落不到别的 session。
if (relFromTasks.split(path.sep).length > 1) {
let dirChk = cwd;
for (let guard = 0; guard < 32 && dirChk !== DEFAULT_CWD; guard++) {
let ds = null;
try { ds = fs.lstatSync(dirChk); } catch (_) { /* ENOENT: 继续向上找第一个存在的祖先 */ }
if (ds) {
if (ds.isSymbolicLink()) return { ok: false, reason: 'cwd 路径链中存在符号链接' };
if (!ds.isDirectory()) return { ok: false, reason: 'cwd 不是目录' };
break;
}
const up = path.dirname(dirChk);
if (up === dirChk) break;
dirChk = up;
}
}
let realFull;
try { realFull = fs.realpathSync(realSession); } catch (_) { return { ok: false, reason: 'realpath 失败' }; }
if (!isUnder(realFull, ISOLATION_BASE)) return { ok: false, reason: 'realpath 越出基路径' };
// 5.1) session 子路径逃逸校验(修复 link_etc 漏洞):
// 上面只校验了 session 名本身,AI 可以在 session 内 ln -s /etc link,再把 cwd
// 指到 <session>/link —— wrapper 的 cd 在父 ns 视图解析符号链接,直接落到 /etc。
// 这里对 session 之下的每一级做 lstat 拒符号链接 + realpath 确认未离开本 session。
const relInside = path.relative(path.join(DEFAULT_CWD, sessionName), cwd);
if (relInside !== '') {
// 从真实 session 根逐段下钻;curReal 始终是当前已验证前缀的真实路径。
// 某级不存在时:符号链接不可能藏在其中,后续各级必然也不存在(ENOENT),
// 直接交给 wrapper 在子 ns 里 mkdir -p(只落在本会话 bind 内)。
let curReal = realFull;
const segs = relInside.split(path.sep);
for (let i = 0; i < segs.length; i++) {
const seg = segs[i];
if (!seg || seg === '.' || seg === '..') return { ok: false, reason: '非法路径段' };
const probe = path.join(curReal, seg);
let ss;
try { ss = fs.lstatSync(probe); } catch (_) { break; } // 不存在 → 停止校验,交 wrapper 创建
if (ss.isSymbolicLink()) return { ok: false, reason: 'session 子路径不得含符号链接' };
if (!ss.isDirectory()) return { ok: false, reason: 'cwd 不是目录' };
let rr;
try { rr = fs.realpathSync(probe); } catch (_) { return { ok: false, reason: 'realpath 失败' }; }
if (!isUnder(rr, realFull)) return { ok: false, reason: 'realpath 越出 session 边界' };
curReal = rr;
}
}
return {
ok: true, cwd,
plan: {
mode: 'session', sessionName, cwd, realSession: realFull,
virtSession: path.join(DEFAULT_CWD, sessionName),
},
};
}
// 6) 以下路径在父 ns 中真实存在,可做完整校验。
// 深层缺失目录(典型:scratch/<新会话>/子路径)逐级向上找到第一个存在的祖先校验;
// 缺失的尾部由 wrapper 在子 ns 内 mkdir -p(scratch 根已被私有 tmpfs 遮盖,不会落盘)。
let st;
let exist = cwd;
for (let guard = 0; guard < 32; guard++) {
try { st = fs.lstatSync(exist); break; } catch (_) {}
const up = path.dirname(exist);
if (up === exist) return { ok: false, reason: 'cwd 不存在' };
exist = up;
}
if (!st) return { ok: false, reason: 'cwd 不存在' };
if (st.isSymbolicLink()) return { ok: false, reason: 'cwd 不得是符号链接' };
if (!st.isDirectory()) return { ok: false, reason: 'cwd 不是目录' };
// 父链软链检查(从实际存在的最深点往上)
let cur = exist;
for (let guard = 0; guard < 32; guard++) {
let s = null;
try { s = fs.lstatSync(cur); } catch (_) { break; }
if (s && s.isSymbolicLink()) return { ok: false, reason: 'cwd 路径链中存在符号链接' };
const up = path.dirname(cur);
if (up === cur) break;
cur = up;
}
try {
const real = fs.realpathSync(exist); // 用实际存在的最深点;缺失尾部由 wrapper 补建
if (!ROOTS.some(r => isUnder(real, r))) return { ok: false, reason: 'realpath 越界' };
if (isUnder(real, ISOLATION_BASE)) return { ok: false, reason: 'realpath 命中隔离基路径' };
} catch (_) {
return { ok: false, reason: 'realpath 失败' };
}
// 7) skills 必须确实只读(compose 用 :ro 保证,这里二次确认,避免误挂成 rw)
if (isUnder(cwd, SKILLS_DIR)) {
try {
fs.accessSync(cwd, fs.constants.W_OK);
return { ok: false, reason: 'skills 目录应为只读' };
} catch (e) {
if (e.code !== 'EROFS' && e.code !== 'EACCES' && e.code !== 'EPERM') throw e;
}
}
// 8) scratch:私有 tmpfs,不给任何真实数据
if (isUnder(cwd, SCRATCH_ROOT)) {
const seg = path.relative(SCRATCH_ROOT, cwd).split(path.sep)[0];
if (!seg || seg === '.' || seg === '..') return { ok: false, reason: '非法 scratch 名' };
return { ok: true, cwd, plan: { mode: 'scratch', cwd, scratchDir: path.join(SCRATCH_ROOT, seg) } };
}
// 9) 其余(如 /workspace/skills/<name>)→ 只跑公共加固
return { ok: true, cwd, plan: { mode: 'plain', cwd } };
}
// ---------- HTTP ----------
function tokenOk(req) {
if (!TOKEN) return true;
const auth = String(req.headers.authorization || '');
const got = auth.startsWith('Bearer ') ? auth.slice(7) : '';
const a = Buffer.from(got), b = Buffer.from(TOKEN);
if (a.length !== b.length) return false;
return crypto.timingSafeEqual(a, b);
}
function send(res, status, obj) {
log.debug('resp', status, brief(JSON.stringify(obj)));
res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
res.end(JSON.stringify(obj));
}
function readJsonBody(req) {
return new Promise((resolve, reject) => {
let size = 0; const chunks = [];
req.on('data', c => {
size += c.length;
if (size > BODY_LIMIT) { reject(new Error('请求体超过 ' + BODY_LIMIT + ' 字节')); req.destroy(); return; }
chunks.push(c);
});
req.on('end', () => {
try { resolve(chunks.length ? JSON.parse(Buffer.concat(chunks).toString('utf8')) : {}); }
catch (e) { reject(new Error('body 不是合法 JSON:' + e.message)); }
});
req.on('error', reject);
});
}
function killGroup(entry) {
const child = entry.child;
try { process.kill(-child.pid, 'SIGKILL'); }
catch (_) { try { child.kill('SIGKILL'); } catch (__) { /* 已退出 */ } }
}
function sseWrite(res, obj) {
log.debug('sse →', brief(JSON.stringify(obj)));
if (res.writableEnded || res.destroyed) return;
res.write('data: ' + JSON.stringify(obj) + '\n\n');
}
async function handleExec(req, res) {
let args;
try { args = await readJsonBody(req); } catch (e) { return send(res, 400, { error: e.message }); }
log.debug('exec ←', brief(JSON.stringify(args)));
const command = String(args.command || '');
if (!command.trim()) return send(res, 400, { error: 'command 必填' });
const rawCwd = args.cwd ? String(args.cwd) : DEFAULT_CWD;
const rc = resolveCwd(rawCwd);
if (!rc.ok) {
log.warn('reject', req.socket.remoteAddress, 'cwd=' + brief(rawCwd, 200), 'reason=' + rc.reason);
return send(res, 400, { error: 'cwd 非法或不在白名单目录内' }); // 不回吐 ROOTS,避免侦察
}
let timeout = parseInt(args.timeout_ms, 10);
if (!isFinite(timeout) || timeout <= 0) timeout = 5 * 60 * 1000;
timeout = Math.min(Math.max(timeout, 1000), MAX_TIMEOUT);
let maxChars = parseInt(args.max_output_chars, 10);
if (!isFinite(maxChars) || maxChars <= 0) maxChars = DEFAULT_MAX_OUT;
maxChars = Math.min(maxChars, DEFAULT_MAX_OUT);
// 环境变量白名单
const env = {};
for (const key of ['PATH', 'HOME', 'LANG', 'LC_ALL', 'TZ', 'PYTHONUNBUFFERED',
'PYTHONDONTWRITEBYTECODE', 'PYTHONPYCACHEPREFIX', 'MPLBACKEND']) {
if (process.env[key]) env[key] = process.env[key];
}
if (args.env && typeof args.env === 'object') {
for (const [k, v] of Object.entries(args.env)) {
const K = String(k);
if (/^(EXECUTOR_.*|.*TOKEN|.*SECRET|.*PASSWORD|.*KEY)$/i.test(K)) continue;
if (/^(LD_PRELOAD|LD_LIBRARY_PATH|NODE_OPTIONS|NODE_REPL_EXTERNAL_MODULE|PYTHONSTARTUP|GIT_CONFIG_GLOBAL|GIT_CONFIG_SYSTEM|BASH_ENV|ENV|PROMPT_COMMAND|GLOBIGNORE)$/.test(K)) continue;
env[K] = String(v);
}
}
if (!env.PATH) env.PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
env.HOME = '/tmp'; // 指向会话私有 tmpfs,不污染镜像层
env.TMPDIR = '/tmp';
env.PYTHONDONTWRITEBYTECODE = '1';
env.PYTHONPYCACHEPREFIX = '/tmp/pycache';
const script = buildIsolation(command, rc.plan);
const id = crypto.randomUUID();
let child;
try {
// spawn 的 cwd 用父 ns 下确实存在的 ROOTS[0];真正的目标目录由 wrapper 内部 cd 完成
//(session 的虚拟视图只存在于子 ns)。--propagation private 防止 bind 反向传播回宿主 ns。
child = spawn('unshare', ['--mount', '--pid', '--fork', '--propagation', 'private', '/bin/sh', '-c', script],
{ cwd: ROOTS[0], env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
} catch (e) {
log.error('spawn 失败', e.message);
return send(res, 500, { error: '执行环境启动失败' });
}
const entry = { child, killedBy: null, started_at: Date.now(), cwd: rc.cwd, timer: null };
runs.set(id, entry);
log.info('start', id, 'pid=' + child.pid, 'cwd=' + rc.cwd, 'mode=' + rc.plan.mode, 'timeout=' + timeout + 'ms');
res.writeHead(200, {
'Content-Type': 'text/event-stream; charset=utf-8',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'X-Accel-Buffering': 'no',
});
const ping = setInterval(() => { if (!res.writableEnded && !res.destroyed) res.write(': ping\n\n'); }, PING_MS);
sseWrite(res, { type: 'start', id, pid: child.pid, cwd: rc.cwd });
const out = { stdout: 0, stderr: 0, truncated: false };
function streamChunk(kind, chunk) {
const key = kind === 'out' ? 'stdout' : 'stderr';
const text = chunk.toString('utf8');
const remain = maxChars - out[key];
if (remain <= 0) { out.truncated = true; return; }
if (text.length > remain) {
out.truncated = true;
sseWrite(res, { type: kind, chunk: text.slice(0, remain) });
out[key] = maxChars;
return;
}
out[key] += text.length;
sseWrite(res, { type: kind, chunk: text });
}
child.stdout.on('data', c => streamChunk('out', c));
child.stderr.on('data', c => streamChunk('err', c));
entry.timer = setTimeout(() => { entry.killedBy = 'timeout'; killGroup(entry); }, timeout);
res.on('close', () => {
if (runs.has(id)) { entry.killedBy = entry.killedBy || 'disconnected'; killGroup(entry); }
});
function finish(code) {
if (!runs.has(id)) return;
clearTimeout(entry.timer); clearInterval(ping); runs.delete(id);
log.info('exit ', id, 'code=' + code, 'killed_by=' + entry.killedBy);
if (res.writableEnded || res.destroyed) return;
sseWrite(res, {
type: 'exit', code, signal: child.signalCode, killed_by: entry.killedBy,
stdout_chars: out.stdout, stderr_chars: out.stderr, truncated: out.truncated,
});
res.end();
}
child.on('error', err => {
entry.killedBy = entry.killedBy || 'spawn_error';
log.error('spawn error', id, err.message);
streamChunk('err', Buffer.from('执行环境启动失败\n'));
finish(-1);
});
child.on('close', code => finish(entry.killedBy ? -1 : (code === null ? -1 : code)));
}
function handleKill(req, res, id) {
const entry = runs.get(id);
if (!entry) return send(res, 404, { error: '没有该执行任务' });
entry.killedBy = 'cancelled';
killGroup(entry);
send(res, 200, { ok: true, id });
}
const server = http.createServer(async (req, res) => {
log.debug('req ', req.method, req.url);
const url = new URL(req.url, 'http://x');
const seg = url.pathname.split('/').filter(Boolean);
if (url.pathname === '/health') return send(res, 200, { ok: true, time: Date.now() });
if (!tokenOk(req)) {
log.warn('auth', '拒绝', req.method, url.pathname);
return send(res, 401, { error: '鉴权失败' });
}
try {
if (req.method === 'POST' && url.pathname === '/exec') return await handleExec(req, res);
if (req.method === 'DELETE' && seg.length === 2 && seg[0] === 'exec') return handleKill(req, res, seg[1]);
} catch (e) {
log.error('处理异常:', e.message);
if (!res.headersSent) send(res, 500, { error: '内部错误' }); else res.end();
return;
}
send(res, 404, { error: '未知路由' });
});
server.listen(PORT, () => {
log.info('listening on ' + PORT +
' roots=' + ROOTS.join(', ') +
' default_cwd=' + DEFAULT_CWD +
' isolation_base=' + ISOLATION_BASE +
' scratch=' + SCRATCH_ROOT +
' auth=' + (TOKEN ? 'on' : 'off'));
selfCheck();
});
function shutdown(sig) {
log.info('收到 ' + sig + ',停止服务');
for (const entry of runs.values()) { entry.killedBy = 'shutdown'; killGroup(entry); }
server.close(() => process.exit(0));
setTimeout(() => process.exit(0), 3000).unref();
}
process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));