Files
agent/app/server/tools/executor.js
T
kicer 23ede0fe61 refactor(schedule): 评审落地——schema 去重提级、script 语义澄清、'0' 魔法值移除、brief 帽对齐文档
砖家评审逐条处置(采纳为主,两处按项目现实驳回):
- ①冗余合并:时区/id 规则/每会话一任务各只说一次;但 Required with op=X 的双写
  (description 行 + 参数一句)是 tool-design.md §四 明文规范,保留;
- ②create 副作用提级为独立 'Side effect:' 行,不再夹在句中;
- ③轻补返回语义一行(k=v 块 / 'Error: ...' 可修正重试),不枚举错误场景(现场回显即真语义);
- ④驳回 allOf/if-then:多平台 function-calling 子集不保证支持,严格端点 400、宽容端点忽略,
  收益归零风险为正;§四 紧凑格式就是本环境的答案;
- ⑤script 澄清三点写进描述:提供即「本回合把它写出来」、创建后不可改、缺失脚本由触发回合
  报错现场处理(非静默);
- ⑥'0' 删除(用户拍板:莫名其妙):target()/create 检查/schema 三处同步,omit 即本会话;
- ⑦揪出真 bug:文档说 brief<=40 字符、代码截 80——统一到 40,并注明 CJK 按字计、创建后不可变。

探针 6 项:省略 id 全链路正常、id='0' get/create 均拒、brief 实际截 40、list/get 无回归。
2026-09-29 19:00:54 +08:00

1477 lines
76 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.
// 工具执行器(内置工具)。所有文件路径强制解析到任务目录内(防路径穿越)。
// 工具名与参数 schema 来自 definitions.json;MCP 工具不在这里,见 ../mcp.js。
const fs = require('fs');
const path = require('path');
const net = require('net'); // fetch SSRF 防护:IP 字面量/解析结果判私网
const dns = require('dns').promises; // 同上:主机名 → IP 后统一判定
const fsp = require('fs').promises;
const { spawn } = require('child_process');
const mcp = require('../mcp');
const skills = require('./skills');
const Database = require('better-sqlite3'); // db 工具:会话目录下的 data.db(同步 API,与单进程模型契合)
const rexec = require('../remote-exec');
const publicFiles = require('../public-files');
const scheduler = require('../scheduler'); // 只依赖 log/cron-parser,不成环(engine→executor→scheduler 单向)
const profile = require('../user-profile'); // profile 工具的数据面(仅 llm/log 依赖,无环)
const memory = require('../memory'); // recall 工具的数据面(日记翻阅;零依赖模块,无环)
// lab 的 help 伪工具要读全量定义:与 engine 同路径 require → node 缓存同一对象,单一事实源。
const BUILTIN_TOOL_DEFS = require('./definitions.json');
// ---------- 路径沙箱 ----------
function resolveInTask(taskDir, p) {
if (typeof p !== 'string' || !p.trim()) throw new Error('路径不能为空');
let abs;
if (path.isAbsolute(p)) {
abs = path.normalize(p);
} else {
abs = path.resolve(taskDir, p);
}
const root = path.resolve(taskDir);
if (abs !== root && !abs.startsWith(root + path.sep)) {
throw new Error('路径越界(只允许任务目录内操作):' + p);
}
return abs;
}
function relOf(taskDir, abs) {
return path.relative(path.resolve(taskDir), abs) || '.';
}
function isProbablyBinary(abs) {
let fd;
try {
fd = fs.openSync(abs, 'r');
const buf = Buffer.alloc(8192);
const bytes = fs.readSync(fd, buf, 0, buf.length, null);
if (bytes === 0) return false;
const slice = buf.slice(0, bytes);
return slice.includes(0);
} catch (_) {
return true;
} finally {
if (fd !== undefined) try { fs.closeSync(fd); } catch (_) {}
}
}
function truncate(text, max) {
if (text.length <= max) return text;
return text.slice(0, max) + '\n...(输出已截断,共 ' + text.length + ' 字符)';
}
// ---------- 各工具实现 ----------
// 对齐 Zed:整读时文件字节数超过该阈值则返回大纲(outline),而非截断内容。
const AUTO_OUTLINE_SIZE = 16384;
// 全文读/编辑的硬上限:超过即拒绝整读进内存(OOM 防护,st.size 在 read 前就有),引导走 terminal。
const TEXT_FULL_READ_CAP = 32 * 1024 * 1024;
const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.tiff', '.tif']);
// read_file 读图(仅当会话绑定的模型 vision: true):sharp 压缩后落盘到任务目录 .imgcache/,
// 返回 {text, image_rel};engine 拼成 image_ref 内容块落库,llm.buildMessages 发请求前
// 现签成公网外链(GET /p/<id>)进 image_url 块,base64 不再进 DB/请求体。
const IMG_MAX_INPUT_BYTES = 50 * 1024 * 1024; // 与上传上限一致
const IMG_MAX_SIDE = 2000; // 长边压缩阈值(px)
const IMG_JPEG_QUALITY = 80;
// 简化版符号大纲(Zed 用 tree-sitter,这里用正则提取常见语言的顶层符号 + Markdown 标题)。
// 返回 "# File outline ..." 文本;无法提取时返回 null(调用方回退到首 1KB)。
const OUTLINE_RES = [
/^\s*(?:export\s+default\s+|export\s+|default\s+|pub(?:\([^)]*\))?\s+)?(?:pub\s+)?(?:async\s+)?(?:function|fn|func|def|sub)\s+\*?([A-Za-z0-9_]+)/,
/^\s*(?:export\s+)?(?:default\s+)?(?:pub(?:\([^)]*\))?\s+)?(?:pub\s+)?(?:abstract\s+|final\s+|open\s+|sealed\s+|data\s+|implicit\s+)*(?:class|struct|trait|interface|enum|impl|namespace|module|type|record|union)\s+([A-Za-z0-9_<>,\[\] ]{1,60}?)(?:\s*[{:<(]|\s*$)/,
/^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z0-9_]+)\s*(?::[^=]+)?=\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z0-9_]+\s*=>)/,
];
function buildOutline(absPath, text) {
const ext = path.extname(absPath).toLowerCase();
const lines = text.split('\n');
const items = [];
if (ext === '.md' || ext === '.markdown' || ext === '.rst') {
for (let i = 0; i < lines.length; i++) {
const m = /^(#{1,6})\s+(.*)$/.exec(lines[i]);
if (m) items.push({ depth: m[1].length - 1, name: m[2].trim().slice(0, 80), line: i + 1 });
}
} else {
for (let i = 0; i < lines.length; i++) {
for (const re of OUTLINE_RES) {
const m = re.exec(lines[i]);
if (m) {
const indent = (/^[ \t]*/.exec(lines[i])[0] || '').length;
items.push({ depth: Math.min(8, Math.floor(indent / 2)), name: m[1].trim(), line: i + 1 });
break;
}
}
if (items.length >= 500) break;
}
}
if (!items.length) return null;
const body = items.map(it => ' '.repeat(it.depth) + it.name + ' [L' + it.line + ']').join('\n');
return '# File outline for ' + absPath + '\n\n' + body +
'\n\nShowing symbols 1-' + items.length + ' (total symbols: ' + items.length + ')\n';
}
// Zed 同款的大纲包裹文案(模型对该格式有既成预期)。
function outlineWrapper(outlineText) {
return 'SUCCESS: File outline retrieved. This file is too large to read all at once, so the outline below shows the file\'s structure with line numbers.\n\n' +
'IMPORTANT: Do NOT retry this call without line numbers - you will get the same outline.\n' +
'Instead, use the line numbers below to read specific sections by calling this tool again with start_line and end_line parameters.\n\n' +
outlineText + '\n' +
'NEXT STEPS: To read a specific symbol\'s implementation, call read_file with the same path plus start_line and end_line from the outline above.\n' +
'For example, to read a function shown as [L100-150], use start_line: 100 and end_line: 150.';
}
// 用 sharp 压缩(按 EXIF 摆正、长边 ≤2000px、JPEG 质量 80)并落盘 .imgcache/。
// 成功返回 {text, image_rel};产物文件名带源文件指纹(mtime+size),同图重复读复用同一份不增殖。
// 无收益守卫(与浏览器端压缩同款):重编码 JPEG 反而 ≥ 原图时不落盘,image_rel 直指原文件。
// sharp 缺失或解码失败时退回纯文本提示,不让整个工具回合报错。
async function readImageAsBlocks(ctx, abs, rel, size) {
let sharp;
try { sharp = require('sharp'); }
catch (_) { return '[图片文件] ' + rel + '(' + size + ' 字节)。服务端未安装 sharp,无法压缩回传图片内容。'; }
try {
const r = await sharp(abs)
.rotate()
.resize({ width: IMG_MAX_SIDE, height: IMG_MAX_SIDE, fit: 'inside', withoutEnlargement: true })
.jpeg({ quality: IMG_JPEG_QUALITY })
.toBuffer({ resolveWithObject: true });
if (r.data.length >= size) {
// 低内容熵图(截图/线稿/纯色)JPEG 重编码可能比原图还大:不产出缓存,外链直接指向原文件
return {
text: '[图片文件] ' + rel + '(' + size + ' 字节,压缩无收益,按原图回传)',
image_rel: rel,
};
}
let st = null;
try { st = await fsp.stat(abs); } catch (_) {}
const stem = path.basename(rel).replace(/\.[^.]+$/, '').replace(/[^\w.\-\u4e00-\u9fff]/g, '_').slice(0, 60);
const cacheRel = '.imgcache/' + (stem || 'img') + '-' + size + '-' + Math.round(st ? st.mtimeMs : 0) + '.jpg';
const outAbs = path.join(ctx.taskDir, cacheRel);
if (!fs.existsSync(outAbs)) {
await fsp.mkdir(path.dirname(outAbs), { recursive: true });
await fsp.writeFile(outAbs, r.data);
}
return {
text: '[图片文件] ' + rel + '(原 ' + size + ' 字节,已压缩为 ' + r.info.width + '×' + r.info.height +
' JPEG ' + r.data.length + ' 字节)',
image_rel: cacheRel,
};
} catch (err) {
return '[图片文件] ' + rel + '(' + size + ' 字节),图片解码/压缩失败:' + (err && err.message || err);
}
}
async function toolReadFile(ctx, args) {
const abs = resolveInTask(ctx.taskDir, args.path);
let st;
try { st = await fsp.stat(abs); }
catch (_) { throw new Error('文件不存在:' + args.path); }
if (st.isDirectory()) throw new Error(args.path + ' 是目录不是文件,请用 terminal 执行 ls 查看目录内容。');
if (IMAGE_EXTS.has(path.extname(abs).toLowerCase())) {
const rel = relOf(ctx.taskDir, abs);
if (!ctx.vision) {
return '[图片文件] ' + rel + '(' + st.size + ' 字节)。图片文件,当前模型不支持视觉识别,无法回传图片内容。';
}
if (st.size > IMG_MAX_INPUT_BYTES) {
return '[图片文件] ' + rel + '(' + st.size + ' 字节)过大(上限 ' + IMG_MAX_INPUT_BYTES + ' 字节),已跳过回传。';
}
return await readImageAsBlocks(ctx, abs, rel, st.size);
}
if (isProbablyBinary(abs)) return '[二进制文件,跳过文本读取] ' + relOf(ctx.taskDir, abs);
if (st.size > TEXT_FULL_READ_CAP) {
return '(文件过大:' + Math.round(st.size / 1048576) + ' MB,超过 read_file 全文读取上限 '
+ (TEXT_FULL_READ_CAP / 1048576) + ' MB,拒绝整读;请用 terminal 的 grep -n / head / sed -n 定位阅读)';
}
const text = await fsp.readFile(abs, 'utf8');
if (!text) return '(空文件)';
let lines = text.split('\n');
// CRLF 文件显示层剥去行尾 \r:模型拿到的行更干净;edit_file 精确/模糊匹配与 CRLF 归一不受影响。
if (text.includes('\r\n')) lines = lines.map(l => (l.endsWith('\r') ? l.slice(0, -1) : l));
const total = lines.length;
const startLine = Math.max(1, args.start_line || 1);
let endLine = args.end_line || total;
if (startLine > total) return '(文件共 ' + total + ' 行,start_line 超出范围)';
// 显式拒绝而非 slice 出空串静默返回:空串会让模型误判文件为空/工具坏了而换路重试。
if (endLine < startLine) throw new Error('end_line 必须 >= start_line(got start_line=' + startLine + ', end_line=' + args.end_line + ')');
// 对齐 Zed:未指定范围且文件超过 16KB 时返回大纲;提取不到大纲则回退回首 1KB。
if (!args.start_line && !args.end_line && Buffer.byteLength(text, 'utf8') > AUTO_OUTLINE_SIZE) {
const outline = buildOutline(abs, text);
if (outline) return outlineWrapper(outline);
let head = text.slice(0, 1024);
try { while (Buffer.byteLength(head, 'utf8') > 1024) head = head.slice(0, -1); } catch (_) {}
return outlineWrapper('# First 1KB of ' + abs + ' (file too large to show full content, and no outline available)\n\n' + head);
}
lines = lines.slice(startLine - 1, Math.min(endLine, total));
return lines.map((l, i) => String(startLine + i).padStart(6, ' ') + '\t' + l).join('\n');
}
async function toolWriteFile(ctx, args) {
const abs = resolveInTask(ctx.taskDir, args.path);
// 纵深防御:引擎 checkToolArgs 已把 null 判缺,但直调 executor(测试等)不经过它;
// 旧版 `?? ''` 会把 null 洗成空串静默清空已有文件,这里显式拒绝。
if (args.content == null) throw new Error('write_file 缺少参数 content(写空文件请显式传空字符串 "")');
let st = null;
try { st = await fsp.stat(abs); } catch (_) {}
if (st && st.isDirectory()) throw new Error('无法写入:路径是目录 ' + args.path);
await fsp.mkdir(path.dirname(abs), { recursive: true });
await fsp.writeFile(abs, String(args.content), 'utf8');
recordFile(ctx, abs);
const nbytes = Buffer.byteLength(String(args.content), 'utf8');
const rel = relOf(ctx.taskDir, abs);
// 区分新建/覆盖:「原 M 字节」是给模型的止损信号(盲覆盖大文件时能立刻察觉)。
return st
? '已覆盖文件 ' + rel + '(' + nbytes + ' 字节,原 ' + st.size + ' 字节)'
: '已创建文件 ' + rel + '(' + nbytes + ' 字节)';
}
// ---------- edit_file 匹配(对齐 Zed edit_session/streaming_fuzzy_matcher 的终止态语义) ----------
// Zed 常量:替换代价 1,插入(buffer 多余行)3,删除(query 行未命中)10;模糊相似阈值 0.8。
const COST_REP = 1, COST_INS = 3, COST_DEL = 10, FUZZY_THRESHOLD = 0.8;
const FUZZY_DP_CELL_LIMIT = 8_000_000; // 超大文件跳过 DP,退回逐行 trim 扫描
// normalized Levenshtein 相似度(1 - lev/max_len),先做长度粗筛。
// DP 工作集复用模块级 buffer:lineSimilarity 无递归/无重入(单线程下安全),
// 避免 fuzzyLocate m×n 内层每格新建两个 typed array(触顶时是千万次临时分配)。
let simPrev = null, simCurr = null;
function lineSimilarity(a, b) {
if (a === b) return 1;
const la = a.length, lb = b.length, max = Math.max(la, lb);
if (max === 0) return 1;
if (1 - Math.abs(la - lb) / max < FUZZY_THRESHOLD) return 0;
if (!simPrev || simPrev.length < lb + 1) {
simPrev = new Int32Array(lb + 1);
simCurr = new Int32Array(lb + 1);
}
let prev = simPrev, curr = simCurr; // 下面的交换只换局部引用,不动模块级变量
for (let j = 0; j <= lb; j++) prev[j] = j;
for (let i = 1; i <= la; i++) {
curr[0] = i;
const ca = a.charCodeAt(i - 1);
for (let j = 1; j <= lb; j++) {
const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
}
const t = prev; prev = curr; curr = t;
}
return 1 - prev[lb] / max;
}
function diagCost(trimOld, trimCur) {
if (trimOld === trimCur) return 0;
if (lineSimilarity(trimOld, trimCur) >= FUZZY_THRESHOLD) return COST_REP;
return COST_DEL + COST_INS;
}
function lineNumberOf(text, idx) {
let n = 1;
for (let i = 0; i < idx; i++) if (text.charCodeAt(i) === 10) n++;
return n;
}
// 全局 DP 对齐(query 行 × buffer 行,逐行 trim 比较)。
// 返回 { startRow, endRow };找不到返回 null;多个同分候选返回 { ambiguous: [rows] }。
function fuzzyLocate(curLines, oldLinesTrim) {
const m = oldLinesTrim.length, n = curLines.length;
const curTrim = new Array(n);
for (let c = 0; c < n; c++) curTrim[c] = curLines[c].trim();
const W = n + 1;
const INF = Number.POSITIVE_INFINITY;
let dpPrev = new Float64Array(W), dpCur = new Float64Array(W);
const dir = new Uint8Array((m + 1) * W); // bit1=diag bit2=up(删 query 行) bit4=left(跳过 buffer 行)
for (let c = 0; c < W; c++) { dpPrev[c] = c * COST_INS; dir[c] = 4; }
for (let r = 1; r <= m; r++) {
dpCur[0] = dpPrev[0] + COST_DEL; dir[r * W] = 2;
const qt = oldLinesTrim[r - 1];
for (let c = 1; c <= n; c++) {
const d = dpPrev[c - 1] + diagCost(qt, curTrim[c - 1]);
const u = dpPrev[c] + COST_DEL;
const l = dpCur[c - 1] + COST_INS;
let best = d, bits = 1;
if (u < best) { best = u; bits = 2; }
if (l < best) { best = l; bits = 4; }
dpCur[c] = best; dir[r * W + c] = bits;
}
const t = dpPrev; dpPrev = dpCur; dpCur = t;
}
// 末行最小代价的所有列 → 逐列回溯成候选,按 (startRow,endRow) 去重。
let min = INF;
for (let c = 1; c <= n; c++) if (dpPrev[c] < min) min = dpPrev[c];
if (!isFinite(min)) return null;
const seen = new Set(); const candidates = [];
for (let c0 = 1; c0 <= n; c0++) {
if (dpPrev[c0] !== min) continue;
let r = m, c = c0;
const pairs = [];
while (r > 0 && c > 0) {
const bits = dir[r * W + c];
if (bits & 1) {
if (diagCost(oldLinesTrim[r - 1], curTrim[c - 1]) <= COST_REP) pairs.push(c - 1);
r--; c--;
} else if (bits & 2) { r--; }
else { c--; }
}
if (!pairs.length) continue;
// 升序排列并要求连续:不连续区间说明 DP 在中间跳过了无关的 buffer 行(left/13 代价 diag 路径),
// 整段 splice 会静默删掉这些行——这类候选直接丢弃(上层报找不到,模型补上下文重试)。
pairs.sort((a, b) => a - b);
let contiguous = true;
for (let k = 1; k < pairs.length; k++) {
if (pairs[k] !== pairs[k - 1] + 1) { contiguous = false; break; }
}
if (!contiguous) continue;
const startRow = pairs[0], endRow = pairs[pairs.length - 1];
const span = endRow - startRow + 1;
const ratio = pairs.length / Math.max(span, m);
if (ratio < FUZZY_THRESHOLD) continue;
const key = startRow + ':' + endRow;
if (seen.has(key)) continue;
seen.add(key);
candidates.push({ startRow, endRow });
}
if (!candidates.length) return null;
if (candidates.length > 1) return { ambiguous: candidates.map(x => x.startRow + 1) };
return candidates[0];
}
function indentOf(l) { return /^[ \t]*/.exec(l)[0]; }
// 按“缓冲行缩进 - query 行缩进”的差值重排 new_text 缩进(空白行不动)。
function applyReindent(newLines, delta, ch) {
if (delta === 0) return newLines;
return newLines.map(l => {
if (!l.trim()) return l;
const ind = indentOf(l);
const n = Math.max(0, ind.length + delta);
if (n <= ind.length) return ' '.repeat(n) + l.slice(ind.length);
return ind + ch.repeat(n - ind.length) + l.slice(ind.length);
});
}
// 应用单条 edit;失败抛错(含 edit 序号)。对齐 Zed:先精确(含重叠计数,≥2 歧义),
// 再模糊;匹配区间不含行尾换行;new_text 末尾换行仅当缓冲区该位置后有 \n 时吃掉一个。
function applyEdit(text, edit, i) {
const tag = 'edit #' + (i + 1);
const old_text = edit.old_text, new_text = edit.new_text == null ? '' : String(edit.new_text);
if (!old_text) throw new Error(tag + ': old_text 不能为空');
// 尾部行尾换行不计入匹配区间(Zed trailing_line_ending_len)。
let pat = String(old_text);
if (pat.endsWith('\r\n')) pat = pat.slice(0, -2);
else if (pat.endsWith('\n')) pat = pat.slice(0, -1);
if (!pat) pat = String(old_text);
// 1) 精确匹配(含重叠)
const hits = [];
let from = 0;
while (hits.length < 2) {
const idx = text.indexOf(pat, from);
if (idx < 0) break;
hits.push(idx); from = idx + 1;
}
if (hits.length >= 2) {
throw new Error(tag + ': old_text 在文件中匹配到多处(第 ' + hits.map(h => lineNumberOf(text, h)).join(', ') +
' 行附近)。请在 old_text 中包含更多上下文以唯一定位。');
}
const newLinesRaw = new_text.split('\n');
if (hits.length === 1) {
// 精确匹配:原样替换,不重排缩进(Zed first_line_delta=0,精确下 rest 差值必然 0)。
const idx = hits[0];
let repl = new_text;
// 尾换行摘除:匹配区间后紧跟 \n(或 CRLF 的 \r\n)时吃掉 new_text 的一个尾换行。
const after = text.charAt(idx + pat.length);
const afterCRLF = after === '\r' && text.charAt(idx + pat.length + 1) === '\n';
if (afterCRLF) {
// 尾随 \r\n 要整对切;只切 \n 会在拼接处留下孤立的 \r
if (repl.endsWith('\r\n')) repl = repl.slice(0, -2);
else if (repl.endsWith('\n')) repl = repl.slice(0, -1);
} else if (after === '\n' && repl.endsWith('\n')) {
repl = repl.slice(0, -1);
}
// CRLF 文件:新内容里的行尾统一成 \r\n。
if (text.includes('\r\n')) repl = repl.replace(/\r?\n/g, '\r\n');
// 空 new_text 的整行删除:区间恰好行对齐(前邻行首/换行、后随换行)时把尾随行尾一并吃掉,
// 对齐 Zed 空 new_text=删零行(否则 JS 语义会留下一个空行)。
if (repl === '' && (after === '\n' || afterCRLF) &&
(idx === 0 || text.charAt(idx - 1) === '\n' || text.charAt(idx - 1) === '\r')) {
return text.slice(0, idx) + text.slice(idx + pat.length + (afterCRLF ? 2 : 1));
}
return text.slice(0, idx) + repl + text.slice(idx + pat.length);
}
// 2) 模糊匹配(逐行 trim)
const curLines = text.split('\n');
const oldLines = pat.split('\n');
const oldTrim = oldLines.map(l => l.trim());
let loc = null;
let usedFallback = false;
if (oldLines.length * curLines.length <= FUZZY_DP_CELL_LIMIT) {
loc = fuzzyLocate(curLines, oldTrim);
} else {
usedFallback = true;
// 超大文件降级:逐行 trim 首次命中(旧行为)。
for (let s = 0; s + oldLines.length <= curLines.length; s++) {
let ok2 = true;
for (let j = 0; j < oldLines.length; j++) {
if (curLines[s + j].trim() !== oldTrim[j]) { ok2 = false; break; }
}
if (ok2) { loc = { startRow: s, endRow: s + oldLines.length - 1 }; break; }
}
}
if (!loc) {
throw new Error(tag + ': 在文件中找不到 old_text(可能已被之前的 edit 修改)。' + (usedFallback
? '文件过大,本次仅走了降级匹配(逐行 trim 精确相等、无相似度容忍):请核对 old_text 与原文是否逐字一致,或改用 read_file 按行号定位后用 terminal 的 sed 编辑,不要以同一文本反复重试。'
: '请重新 read_file 获取最新内容后再试。'));
}
if (loc.ambiguous) {
throw new Error(tag + ': old_text 模糊匹配到多处(第 ' + loc.ambiguous.join(', ') +
' 行附近)。请在 old_text 中包含更多上下文以唯一定位。');
}
const { startRow, endRow } = loc;
// 空 new_text=整行删除:对齐 Zed "".lines() 的零行语义(JS ''.split('\n') 是 1 个空行,会留白);
// new_text='\n' 仍是「替换为一个空行」,语义不合并。
let newLines = new_text === '' ? [] : newLinesRaw;
// 匹配区间后紧跟换行时,吃掉 new_text 的尾换行(防止吞掉行尾)。
const hasNewlineAfter = endRow < curLines.length - 1 || text.endsWith('\n');
if (hasNewlineAfter && newLines.length > 1 && newLines[newLines.length - 1] === '') {
newLines = newLines.slice(0, -1);
}
// 缩进差值重排(以首条匹配行为基准)。
const bufInd = indentOf(curLines[startRow]);
const qInd = indentOf(oldLines[0]);
const delta = bufInd.length - qInd.length;
if (delta !== 0) newLines = applyReindent(newLines, delta, bufInd.includes('\t') ? '\t' : ' ');
// CRLF 文件:新增行补齐 \r。
if (text.includes('\r\n')) newLines = newLines.map(l => (l.endsWith('\r') || l === '' ? l : l + '\r'));
curLines.splice(startRow, endRow - startRow + 1, ...newLines);
return curLines.join('\n');
}
// 对齐 Zed:edits 顺序应用到内存态;若第 N 条失败,前 N-1 条仍保存落盘,
// 错误信息告知模型已应用了多少、需重新 read_file。
async function toolEditFile(ctx, args) {
const abs = resolveInTask(ctx.taskDir, args.path);
let st;
try { st = await fsp.stat(abs); }
catch (_) { throw new Error('文件不存在:' + args.path); }
if (st.isDirectory()) throw new Error('无法编辑:路径是目录 ' + args.path);
// 同 read_file 的 OOM 防护:edit_file 也要全量读入,超限拒操作。
if (st.size > TEXT_FULL_READ_CAP) throw new Error('文件超过 ' + (TEXT_FULL_READ_CAP / 1048576) + 'MB 全文读取上限,edit_file 拒绝操作;请用 terminal 的 sed 等工具编辑');
const edits = args.edits || [];
let text = await fsp.readFile(abs, 'utf8');
const original = text;
let applied = 0;
let failure = null;
for (let i = 0; i < edits.length; i++) {
try { text = applyEdit(text, edits[i], i); applied++; }
catch (err) { failure = err; break; }
}
if (text !== original) {
await fsp.writeFile(abs, text, 'utf8');
recordFile(ctx, abs);
}
if (failure) {
throw new Error(failure.message + (applied > 0
? '(前 ' + applied + ' 处编辑已应用并保存,文件已变化,请重新 read_file 后再继续)'
: '(文件未改动)'));
}
return '已成功应用 ' + applied + ' 处编辑到 ' + relOf(ctx.taskDir, abs);
}
// 对齐 Zed select_terminal_output_lines:head/tail 各自取行;同时给时中间空一行;不去重叠;0 合法。
function selectOutput(text, head, tail) {
const hasH = typeof head === 'number' && isFinite(head);
const hasT = typeof tail === 'number' && isFinite(tail);
if (!hasH && !hasT) return text;
const lines = text.split('\n');
const parts = [];
if (hasH) parts.push(lines.slice(0, Math.max(0, Math.floor(head))).join('\n'));
if (hasT) parts.push(lines.slice(Math.max(0, lines.length - Math.floor(tail))).join('\n'));
return parts.join('\n\n');
}
// terminal:spawn + 进程组 kill + 超时 + 输出截断
async function toolTerminal(ctx, args) {
const cfg = ctx.cfg;
const timeout = args.timeout_ms || cfg.terminal.default_timeout_ms;
const maxChars = cfg.terminal.max_output_chars;
let cwd = ctx.taskDir;
if (args.cd) cwd = resolveInTask(ctx.taskDir, args.cd);
if (!fs.existsSync(cwd)) throw new Error('工作目录不存在:' + cwd);
// 配了 executor.url(或 env EXECUTOR_URL):命令交给远端 agent-executor 执行,文本拼回与本地完全一致。
if (rexec.isRemote(cfg)) {
const r = await rexec.run(cfg, { command: args.command, cwd, timeout_ms: timeout, run: ctx.run });
let text = selectOutput(r.out.replace(/\n+$/, ''), args.head_lines, args.tail_lines);
if (r.killed_by === 'timeout') {
text += (text ? '\n' : '') + '(命令超时 ' + timeout + 'ms,已终止;这是超时不是命令本身失败)';
} else if (r.killed_by === 'cancelled') {
text += (text ? '\n' : '') + '(用户终止任务,进程被 kill)';
} else {
text += (text ? '\n' : '') + '[exit code: ' + r.code + ']';
}
if (r.truncated) text += '\n(输出超长,已在 executor 侧截断)';
return truncate(text || '(无输出)', maxChars);
}
return new Promise((resolve) => {
const child = spawn('/bin/sh', ['-c', args.command], { cwd, detached: true, env: process.env });
ctx.run.procs.add(child);
let out = '';
let killedBy = null; // 'timeout' | 'cancelled'
let settled = false;
const timer = setTimeout(() => {
killedBy = 'timeout';
killGroup(child);
}, timeout);
const onData = (d) => { out += d.toString(); };
child.stdout.on('data', onData);
child.stderr.on('data', onData);
const finish = (code, extra) => {
if (settled) return;
settled = true;
clearTimeout(timer);
clearInterval(cancelCheck);
ctx.run.procs.delete(child);
// head_lines/tail_lines:对齐 Zed,在原始输出上选段(之前被完全忽略)。
let text = selectOutput(out.replace(/\n+$/, ''), args.head_lines, args.tail_lines);
if (killedBy === 'timeout') {
// 超时/终止不是“执行失败”,不报 exit code(避免 -1 误导模型)。
text += (text ? '\n' : '') + '(命令超时 ' + timeout + 'ms,已终止;这是超时不是命令本身失败)';
} else if (killedBy === 'cancelled') {
text += (text ? '\n' : '') + '(用户终止任务,进程被 kill)';
} else {
text += (text ? '\n' : '') + '[exit code: ' + code + ']';
}
if (extra) text += '\n' + extra;
resolve(truncate(text || '(无输出)', maxChars));
};
child.on('error', err => finish(-1, 'spawn 失败:' + err.message));
child.on('close', code => finish(killedBy ? -1 : (code === null ? -1 : code)));
const cancelCheck = setInterval(() => {
if (ctx.run.cancelled) { killedBy = 'cancelled'; killGroup(child); }
}, 200);
});
}
function killGroup(child) {
if (!child.pid) return;
try { process.kill(-child.pid, 'SIGKILL'); } catch (_) {
try { child.kill('SIGKILL'); } catch (__) {}
}
}
// fetch:抓取并转 Markdown。超时/取消覆盖到 body 读取完成(非仅响应头);
// 流式读取至多 cfg.fetch.max_bytes 字节(下载上限,宽松);按响应 charset 解码(gbk 等依赖内置 full-icu)。
// 返回上限与下载解耦(cfg.fetch.max_chars/max_chars_hard):超窗尾部拼 offset 续读提示,
// 全文缓在 ctx.run 上(回合级),续读不重抓。SSRF 防护:主机名解析结果含私网即拒,重定向逐跳复查。
// undici 网络错误的 message 恒为 "fetch failed",真因窝在 err.cause 里——不解包模型分不清
// 域名已死/被拒连/TLS 问题(评审实测:只能靠另跑 curl 才能诊断)。常见码翻成中文直述。
const FETCH_NET_ERRORS = {
ENOTFOUND: '域名无法解析(ENOTFOUND,域名可能已不存在)',
EAI_AGAIN: 'DNS 暂时不可用(EAI_AGAIN,可稍后重试)',
ECONNREFUSED: '连接被拒绝(ECONNREFUSED,端口未监听)',
ECONNRESET: '连接被对端重置(ECONNRESET,多为服务端/中间设备拒服务)',
ETIMEDOUT: '连接超时(ETIMEDOUT)',
EHOSTUNREACH: '主机不可达(EHOSTUNREACH)',
ENETUNREACH: '网络不可达(ENETUNREACH)',
EPIPE: '管道断裂(EPIPE)',
EPROTO: '协议错误(EPROTO)',
};
function describeFetchError(err) {
const c = err && err.cause;
const code = c && c.code ? String(c.code).toUpperCase() : '';
const msg = (c && c.message) ? String(c.message) : String((err && err.message) || err);
if (FETCH_NET_ERRORS[code]) return FETCH_NET_ERRORS[code];
if (/self.?signed|certificate|CERT_|UNABLE_TO_/i.test(code + ' ' + msg)) return 'TLS 证书校验失败:' + msg;
return msg + (code ? '(' + code + ')' : '');
}
function isTextualContentType(ct) {
if (!ct) return true; // 未声明:先按文本读,读完用 NUL 字节兜底判定
if (ct.startsWith('text/')) return true;
if (/^application\/(?:[\w.-]+\+)?(?:json|xml|yaml|x-ndjson|ndjson)\b/.test(ct)) return true;
if (/^application\/(?:javascript|ecmascript|xhtml\+xml)\b/.test(ct)) return true;
return false;
}
// ---------- fetch 的 SSRF 防护 ----------
// 私网/保留地址判定(IPv4:回环/私有/链路本地含云元数据 169.254.169.254/CGNAT/基准测试/文档段/组播及保留;
// IPv6:未指定/回环/v4-mapped/ULA fc00::/7/链路本地 fe80::/10/组播)。
function isPrivateIp(ip) {
const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(ip);
if (v4) {
const a = Number(v4[1]), b = Number(v4[2]);
if (a === 0 || a === 10 || a === 127) return true;
if (a === 100 && b >= 64 && b <= 127) return true;
if (a === 169 && b === 254) return true;
if (a === 172 && b >= 16 && b <= 31) return true;
if (a === 192 && (b === 0 || b === 168)) return true;
if (a === 198 && (b === 18 || b === 19 || b === 51)) return true;
if (a === 203 && b === 113) return true;
if (a >= 224) return true;
return false;
}
const s = String(ip).toLowerCase();
const mapped = s.replace(/^::ffff:/, '');
if (mapped.includes('.')) return isPrivateIp(mapped);
if (s === '::' || s === '::1') return true;
if (/^f[cd][0-9a-f]{2}:/.test(s)) return true;
if (/^fe[89ab][0-9a-f]:/.test(s)) return true;
if (/^ff/.test(s)) return true;
return false;
}
// 主机名 → 全部解析结果逐个判,任一私网即拒(不能假定 undici 会连哪一条记录)。
// 残余风险:本函数解析后 undici 建连时还会再解析一次,DNS 重绑定理论上可绕过;
// 目标是拦住直球打内网与重定向借刀这两类主要路径,不承诺硬边界。fetchUserError 标记:
// 这类已直述清楚的错误不走 describeFetchError 再包一层。
async function assertFetchTargetAllowed(u, allowPrivate) {
const host = u.hostname.replace(/^\[|\]$/g, ''); // IPv6 字面量带方括号(URL.hostname 保留)
if (!host) throw Object.assign(new Error('URL 无主机名:' + u.href), { fetchUserError: true });
let ips;
if (net.isIP(host)) ips = [host];
else {
let recs;
try { recs = await dns.lookup(host, { all: true, verbatim: true }); }
catch (e) { throw Object.assign(new Error('无法解析主机 ' + host + (e && e.code ? '(' + e.code + ')' : '')), { fetchUserError: true }); }
ips = recs.map(r => r.address);
}
if (!allowPrivate && ips.some(isPrivateIp)) {
throw Object.assign(new Error('SSRF 防护:目标解析到回环/私有/内网地址(' + host + ' → ' + ips.join(', ') + '),拒绝抓取;' +
'确需抓内网服务请在 config 配 fetch.allow_private: true'), { fetchUserError: true });
}
}
// ---------- fetch 的回合级缓存 ----------
// 返回窗截断时把转换后全文挂到 ctx.run(随 run 消亡,不跨轮污染):offset 续读纯本地切片,
// 不重走网络。键为请求 URL(归一化后);LRU 保留 3 条,每条 ≤ max_bytes,内存上限个位数 MB。
function fetchCacheGet(run, key) {
const c = run && run.fetchCache;
if (!c) return null;
const e = c.get(key);
if (e) { c.delete(key); c.set(key, e); } // 命中挪到最近使用端
return e || null;
}
function fetchCacheSet(run, key, entry) {
if (!run) return;
if (!run.fetchCache) run.fetchCache = new Map();
run.fetchCache.set(key, entry);
while (run.fetchCache.size > 3) run.fetchCache.delete(run.fetchCache.keys().next().value);
}
// 从全文切 [off, off+maxOut) 窗,尾部拼续读提示;窗内无内容单独说明。
// 字节级截断(truncated)时本地「全文」本身就不完整,如实告知末尾可能缺失,
// 避免模型对着不完整文本用 offset 无限续读。
function fetchWindow(text, off, maxOut, hard, truncated, maxBytes) {
if (off >= text.length) {
return '(offset=' + off + ' 超出全文长度 ' + text.length + ' 字符,无内容可读)' +
(truncated ? '\n(源响应体超过抓取上限 ' + maxBytes + ' 字节,可用更大 max_bytes 重抓)' : '');
}
const end = Math.min(text.length, off + maxOut);
let out = text.slice(off, end);
if (end < text.length) {
out += '\n\n(已截断:全文 ' + text.length + ' 字符,本段 ' + off + '–' + end + '。' +
'续读传 offset=' + end + '(不重新下载);单段可传 max_chars 放大,硬帽 ' + hard + ')';
}
if (truncated) out += '\n(源响应体超过抓取上限 ' + maxBytes + ' 字节,内容末尾可能不完整)';
return out;
}
function charsetOf(ct) {
const m = /charset\s*=\s*["']?([\w-]+)/i.exec(ct || '');
return m ? m[1].toLowerCase() : '';
}
// 流式读到 maxBytes 即停;超限 reader.cancel() 主动断开,不再继续下载。
async function readBodyLimited(stream, maxBytes) {
const reader = stream.getReader();
const chunks = [];
let total = 0;
let truncated = false;
try {
for (;;) {
const { done, value } = await reader.read();
if (done) break;
if (total + value.byteLength > maxBytes) {
if (maxBytes > total) chunks.push(value.subarray(0, maxBytes - total));
truncated = true;
break;
}
chunks.push(value);
total += value.byteLength;
}
} finally {
if (truncated) { try { await reader.cancel(); } catch (_) {} }
}
return { buf: Buffer.concat(chunks.map(c => Buffer.from(c))), truncated };
}
async function toolFetch(ctx, args) {
if (ctx.run.cancelled) throw new Error('已终止');
let url = String(args.url || '').trim();
if (!url) throw new Error('fetch 缺少参数 url');
// 对齐 Zed normalize_url:缺 scheme 时默认补 https://;非 http(s) scheme 仍拒绝。
if (!/^https?:\/\//i.test(url)) {
if (/^[a-z0-9+.-]+:\/\//i.test(url)) throw new Error('只支持 http/https URL:' + url);
url = 'https://' + url;
}
const fcfg = (ctx.cfg && ctx.cfg.fetch) || {};
const timeoutMs = fcfg.timeout_ms || 30000;
const maxBytes = fcfg.max_bytes || 1024 * 1024;
// 返回窗与下载上限解耦:下载不进上下文可宽松,返回收紧。模型显式传 max_chars 时夹在硬帽内,
// 非法值(0/负数/NaN)退回默认。
const hard = fcfg.max_chars_hard || 64000;
const want = Math.floor(Number(args.max_chars));
const maxOut = want > 0 ? Math.min(want, hard) : (fcfg.max_chars || 12000);
const off = Math.max(0, Math.floor(Number(args.offset)) || 0);
// 续读/重复抓:命中回合缓存直接本地切片,不再碰网络(回合内页面陈旧可接受,缓存续读场景)。
const hit = fetchCacheGet(ctx.run, url);
if (hit) {
return truncate('HTTP ' + hit.status + '\n' +
fetchWindow(hit.text, off, maxOut, hard, hit.byteTruncated, maxBytes), 1024 * 1024);
}
const ctrl = new AbortController();
const timer = setTimeout(() => ctrl.abort(), timeoutMs);
// 与 toolTerminal 同模式:等待中用户取消也能 abort 掉进行中的请求/读流。
const cancelWatch = setInterval(() => { if (ctx.run.cancelled) ctrl.abort(); }, 200);
try {
// redirect:'manual' + 逐跳 SSRF 校验:自动跟随会让外站 302 直接把我们带进内网(SSRF 主路径)。
let res = null;
let cur = url;
for (let hop = 0; ; hop++) {
await assertFetchTargetAllowed(new URL(cur), !!fcfg.allow_private);
res = await fetch(cur, {
signal: ctrl.signal,
redirect: 'manual',
headers: { 'User-Agent': 'Mozilla/5.0 (agent-app)' },
});
const loc = res.headers.get('location');
if (!loc || res.status < 300 || res.status >= 400) break; // 非跳转:本跳即终答
if (hop >= 5) throw Object.assign(new Error('重定向次数超过上限(5 次):' + url), { fetchUserError: true });
let next;
try { next = new URL(loc, cur); }
catch (_) { throw Object.assign(new Error('重定向 Location 非法:' + loc), { fetchUserError: true }); }
if (next.protocol !== 'http:' && next.protocol !== 'https:') {
throw Object.assign(new Error('重定向目标不是 http/https:' + next.href), { fetchUserError: true });
}
cur = next.href;
}
const ct = (res.headers.get('content-type') || '').toLowerCase();
// 非文本:不读 body,直接回报元信息(避免二进制白下载 + 乱码)。
if (!isTextualContentType(ct)) {
const len = Number(res.headers.get('content-length')) || 0;
return 'HTTP ' + res.status + '\n[非文本响应] content-type=' + ct +
(len ? ',' + len + ' 字节' : '') + ',未读取内容。';
}
if (!res.body) return 'HTTP ' + res.status + '\n(无响应体)';
const { buf, truncated } = await readBodyLimited(res.body, maxBytes);
// content-type 未声明的兜底:前 8KB 含 NUL 判为二进制(与 read_file 的 isProbablyBinary 同口径)。
if (!ct && buf.subarray(0, 8192).includes(0)) {
return 'HTTP ' + res.status + '\n[非文本响应] content-type 未声明,body 疑似二进制(' + buf.length + ' 字节),未返回内容。';
}
// 按 charset 解码;未知/非法编码名退回 UTF-8,不抛错。
const charset = charsetOf(ct);
let text;
if (!charset || charset === 'utf-8' || charset === 'utf8') {
text = buf.toString('utf8');
} else {
try { text = new TextDecoder(charset, { fatal: false }).decode(buf); }
catch (_) { text = buf.toString('utf8'); }
}
let body = ct.includes('html') ? htmlToMarkdown(text) : text;
// 字节截断可能切在多字节字符中间,尾部的 U+FFFD 是噪音,去掉。
if (truncated) body = body.replace(/\uFFFD+$/, '');
const win = fetchWindow(body, off, maxOut, hard, truncated, maxBytes);
// 窗后本地还有未读内容才缓存(续读场景);一窗吃下全文的不值得存。
if (off + maxOut < body.length) {
fetchCacheSet(ctx.run, url, { status: res.status, text: body, byteTruncated: truncated });
}
// engine 不截工具结果;上面的返回窗是主闸门,这行 1MB 字符只是最后兜底。
return truncate('HTTP ' + res.status + '\n' + win, 1024 * 1024);
} catch (err) {
if (err && err.fetchUserError) throw err; // SSRF/重定向等已直述清楚的错误,不再套一层
// 超时与取消都表现为 signal.aborted(body 读流阶段的报错形态不定,按信号判定最稳)。
if (ctrl.signal.aborted) {
if (ctx.run.cancelled) throw new Error('已终止');
throw new Error('fetch 超时(' + timeoutMs + 'ms):' + url);
}
throw new Error('fetch 失败:' + describeFetchError(err));
} finally {
clearTimeout(timer);
clearInterval(cancelWatch);
}
}
// 单遍实体解码:旧版链式 replace 会把 &amp;lt; 双重解码成 <;HTML5 全量表 2000+ 条,
// 这里只收网页文本真正常见的命名实体,数字实体(十进制/十六进制)通吃,认不出的原样保留。
const HTML_ENTITIES = {
nbsp: ' ', ensp: '\u2002', emsp: '\u2003', thinsp: '\u2009', zwnj: '\u200c', zwj: '\u200d', shy: '\u00ad',
amp: '&', lt: '<', gt: '>', quot: '"', apos: "'",
copy: '\u00a9', reg: '\u00ae', trade: '\u2122', deg: '\u00b0', hellip: '\u2026',
mdash: '\u2014', ndash: '\u2013', lsquo: '\u2018', rsquo: '\u2019', sbquo: '\u2018',
ldquo: '\u201c', rdquo: '\u201d', bdquo: '\u201e', laquo: '\u00ab', raquo: '\u00bb',
lsaquo: '\u2039', rsaquo: '\u203a', prime: '\u2032', Prime: '\u2033', bull: '\u2022', middot: '\u00b7',
times: '\u00d7', divide: '\u00f7', plusmn: '\u00b1', frac12: '\u00bd', frac14: '\u00bc', frac34: '\u00be',
sup1: '\u00b9', sup2: '\u00b2', sup3: '\u00b3', micro: '\u00b5', para: '\u00b6', sect: '\u00a7',
dagger: '\u2020', Dagger: '\u2021', permil: '\u2030',
euro: '\u20ac', pound: '\u00a3', yen: '\u00a5', cent: '\u00a2', curren: '\u00a4',
agrave: '\u00e0', aacute: '\u00e1', acirc: '\u00e2', atilde: '\u00e3', auml: '\u00e4', aring: '\u00e5', ccedil: '\u00e7',
egrave: '\u00e8', eacute: '\u00e9', ecirc: '\u00ea', euml: '\u00eb',
igrave: '\u00ec', iacute: '\u00ed', icirc: '\u00ee', iuml: '\u00ef',
ograve: '\u00f2', oacute: '\u00f3', ocirc: '\u00f4', otilde: '\u00f5', ouml: '\u00f6',
ugrave: '\u00f9', uacute: '\u00fa', ucirc: '\u00fb', uuml: '\u00fc',
yacute: '\u00fd', yuml: '\u00ff', ntilde: '\u00f1', szlig: '\u00df',
ne: '\u2260', le: '\u2264', ge: '\u2265', infin: '\u221e', sup: '\u2283', sub: '\u2286',
};
function decodeEntities(s) {
return s.replace(/&#x([0-9a-f]+);|&#(\d+);|&([a-zA-Z][a-zA-Z0-9]*);/gi, (m, hx, dec, name) => {
try {
if (hx) return String.fromCodePoint(parseInt(hx, 16));
if (dec) return String.fromCodePoint(parseInt(dec, 10));
// hasOwnProperty:防 &constructor; 这类名字踩到原型链。
return Object.prototype.hasOwnProperty.call(HTML_ENTITIES, name) ? HTML_ENTITIES[name] : m;
} catch (_) { return m; } // 码点越界等原样保留
});
}
function htmlToMarkdown(html) {
// 标题在剥 head 之前取:head 整块删后页面身份只剩正文,一行标题是性价比最高的上下文。
const tm = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
const title = tm ? decodeEntities(strip(tm[1])).trim() : '';
let s = html
.replace(/<(script|style|noscript|svg|head)[\s\S]*?<\/\1>/gi, '')
// 语义样板整块剥:导航/页眉/页脚/侧栏/表单这类页壳的正文密度普遍低于信噪比门槛。
.replace(/<(nav|header|footer|aside|form)[\s\S]*?<\/\1>/gi, '')
.replace(/<!--[\s\S]*?-->/g, '')
// class/id 命样板词的分块:按启发式整块丢(子串匹配,覆盖 navbar/comments/ad-slot 等变体;
// 同名标签嵌套时惰匹配只删到第一个闭标签,与既有剥除同样接受不完美)。
.replace(/<(div|section|ul|ol|article)\b[^>]*\b(?:class|id)\s*=\s*["'][^"']*(?:nav|menu|sidebar|breadcrumb|comment|footer|related|banner|promo|advert|popup|share|subscribe|masthead|cookie|social|toolbar)[^"']*["'][^>]*>[\s\S]*?<\/\1>/gi, '');
s = s
.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (m, lv, t) => '\n' + '#'.repeat(Number(lv)) + ' ' + strip(t).trim() + '\n')
.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (m, t) => '\n- ' + strip(t).trim())
.replace(/<a[^>]*href=["']?([^"'\s>]+)["']?[^>]*>([\s\S]*?)<\/a>/gi, (m, href, t) => '[' + strip(t).trim() + '](' + href + ')')
.replace(/<(br|hr)[^>]*>/gi, '\n')
.replace(/<\/(p|div|section|article|tr|ul|ol|table|blockquote)>/gi, '\n')
.replace(/<[^>]+>/g, '');
// 实体解码放在剥标签之后:&lt;p&gt; 这类转义文本不会被当成标签剥掉。
const body = decodeEntities(s).replace(/\n{3,}/g, '\n\n').trim();
return (title ? '# ' + title + '\n\n' : '') + body;
}
function strip(s) { return s.replace(/<[^>]+>/g, ''); }
function recordFile(ctx, abs) {
try {
const st = fs.statSync(abs);
if (!st.isFile()) return;
ctx.db.prepare(
'INSERT INTO files (session_id, filename, size, created_at) VALUES (?,?,?,?)'
).run(ctx.sessionId, relOf(ctx.taskDir, abs), st.size, Date.now());
} catch (_) { /* 文件表仅用于展示,失败不影响主流程 */ }
}
// mint_public_link:把当前会话目录里的文件签成一条短命公网链接(由 GET /p/<id> 取用)。
// 这是唯一的签发入口:与 core 同进程,直接调 publicFiles.mint,不必绕任何 HTTP;
// 而 ctx.taskDir 就是会话目录,relOf 的结果正是取用侧(routes/public-files.js)要的 rel。
async function toolMintPublicLink(ctx, args) {
const pl = (ctx.cfg && ctx.cfg.public_link) || {};
if (!pl.base_url) throw new Error('public_link.base_url 未配置,无法签发公网链接');
const abs = resolveInTask(ctx.taskDir, args.path);
const rel = relOf(ctx.taskDir, abs);
if (rel === '.') throw new Error('path 要指向一个文件,不能是任务目录本身');
let st;
try { st = fs.statSync(abs); } catch (_) { throw new Error('文件不存在:' + rel); }
if (!st.isFile()) throw new Error('不是文件:' + rel);
// 符号链接外泄防护:签出去的链接是公网可拉的,realpath 必须仍在任务目录内。
const real = fs.realpathSync(abs);
const rootReal = fs.realpathSync(ctx.taskDir);
if (!real.startsWith(rootReal + path.sep)) {
throw new Error('path 经符号链接指向了任务目录之外,拒绝签发');
}
const id = publicFiles.mint({ sessionId: ctx.sessionId, rel, ttlMs: pl.ttl_ms });
return pl.base_url + '/p/' + id;
}
// schedule:用户全部定时任务的生命周期(op 分派,规范见 docs/tool-design.md)。
// 任务住会话(表主键 session_id → 每会话至多一条),「哪个任务」就用所属会话 id 指认:
// id 省略/'0' = 本会话(兼容旧调用);跨会话操作带 op=list 里看到的 id,同用户校验——
// 用户不切会话,AI 代办一切。create 只落当前会话(定时即下班,建完本会话收口退位成专柜)。
// 回执只给事实,零教学(怎么做写在 schema description 里,不每次复读):
// list 紧凑索引/get 全量详情(编号条目 + key=value 分行,时间 ISO+08:00);写操单一行短确认。
// list 紧凑索引:认任务、看状态够用(name/last_note/prompt 等细节归 get)
function schedEntry(t, idx) {
return [
idx + '. ' + (t.brief || t.title || t.session_id),
'id=' + t.session_id + (t.current ? '(本会话)' : ''),
'cron="' + t.cron_expr + '"',
'next=' + scheduler.fmtIso(t.next_run_at),
t.last_run_at ? 'last=' + scheduler.fmtIso(t.last_run_at) + ' last_status=' + (t.last_status || '-') : 'last=尚未执行',
].join('\n');
}
// get 详情:索引之上补 name(会话标题)、last_note、prompt(原样全量、fence 包裹为引用数据——
// 写入侧已有 2 万字硬帽,读取侧再截就废了 get 的存在意义)——详情字段只在这出现
function schedDetail(t) {
const clip = s => { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length > 160 ? s.slice(0, 160) + '…' : s; };
const lines = ['id=' + t.session_id + (t.current ? '(本会话)' : '')];
if (t.title) lines.push('name=' + t.title);
if (t.brief) lines.push('brief=' + t.brief);
if (t.script) lines.push('script=' + t.script);
lines.push('cron="' + t.cron_expr + '"');
lines.push('next=' + scheduler.fmtIso(t.next_run_at));
if (t.last_run_at) lines.push('last=' + scheduler.fmtIso(t.last_run_at) + ' last_status=' + (t.last_status || '-'));
else lines.push('last=尚未执行');
if (t.last_note) lines.push('last_note=' + clip(t.last_note));
if (t.prompt) {
// fence 包裹:prompt 本体是指令句式,裸贴会被当成对当前模型的命令;`` 标记把它隔成引用数据。
// 动态加长防碰撞:AI 写的 prompt 自身常含 ```(代码样例),固定三反引号会被内容提前闭合并逃逸。
let fence = '```';
while (t.prompt.includes(fence)) fence += '`';
lines.push('prompt=' + fence, t.prompt, fence);
}
return lines.join('\n');
}
function toolScheduleTask(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const cronExpr = String(args.cron_expr || '').trim();
const prompt = String(args.prompt || '').trim();
const db = ctx.db;
const curUser = () => String((db.prepare('SELECT user FROM sessions WHERE id = ?').get(ctx.sessionId) || {}).user || '');
// 目标会话解析:无 id → 本会话;有 id → 存在 + 同用户,否则报错(不静默降级,防 AI 拿错目标静默误删)。
const target = () => {
const raw = String(args.id == null ? '' : args.id).trim();
if (!raw || raw === ctx.sessionId) return ctx.sessionId;
const s = db.prepare('SELECT user FROM sessions WHERE id = ?').get(raw);
if (!s) throw new Error('id 指向的会话不存在:' + raw + '(op=list 可看各任务所属会话 id)');
if (String(s.user || '') !== curUser()) throw new Error('无权操作其他用户的会话任务');
return raw;
};
switch (op) {
case 'get': {
const sid = target();
const t = scheduler.getTask(db, sid);
if (!t) return sid === ctx.sessionId ? '本会话没有定时任务。' : '会话 ' + sid + ' 没有定时任务。';
const srow = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sid);
return schedDetail(Object.assign({ session_id: sid, current: sid === ctx.sessionId, title: srow && srow.title }, t));
}
case 'create': {
const raw = String(args.id == null ? '' : args.id).trim();
if (raw && raw !== ctx.sessionId) throw new Error('op=create 只作用于当前会话:新任务住进本会话并于本回合收尾后收口退位成专柜(定时即下班),无需也不能指定其它会话 id');
if (!cronExpr) throw new Error('op=create 缺少必填参数 cron_expr');
if (!prompt) throw new Error('op=create 缺少必填参数 prompt');
const brief = String(args.brief || '').replace(/\s+/g, ' ').trim().slice(0, 40);
// script 纯标记:存在即暗示模型把流程沉淀成脚本(怎么写、用什么跑、prompt 怎么引用由它自定);
// 创建与触发均不校验——缺脚本时 prompt 自身的指示就是回退面。
const script = String(args.script || '').replace(/\s+/g, ' ').trim().slice(0, 80);
const t = scheduler.createTask(db, ctx.sessionId, cronExpr, prompt, brief, script);
// 定时即下班:标记本回合收尾时由 engine 收口(brief 碎片 + 归档 + 通道解绑,见 engine.taskClockOut)。
if (ctx.onTaskCreated) ctx.onTaskCreated();
return '已创建 id=' + ctx.sessionId + '\ncron="' + t.cron_expr + '"\nnext=' + scheduler.fmtIso(t.next_run_at)
+ (script ? '\nscript=' + script : '')
+ '\n本会话即收口为该任务专柜(用户无感知,下条消息自动进新会话)。';
}
case 'update': {
if (!cronExpr && !prompt) throw new Error('op=update 需要 cron_expr 和 prompt 至少提供一个');
const sid = target();
const t = scheduler.updateTask(db, sid, {
cronExpr: cronExpr || null,
prompt: prompt || null,
});
return '已更新 id=' + sid + '\ncron="' + t.cron_expr + '"\nnext=' + scheduler.fmtIso(t.next_run_at);
}
case 'list': {
// 跨会话全览:编号条目 + key=value 行,id 即行动把手(无任何教学/切会话引导)。
const rows = scheduler.listUserTasks(db, curUser());
if (!rows.length) return '当前没有任何定时任务。';
return '定时任务×' + rows.length + '(按下次执行排序)\n\n'
+ rows.map((t, i) => schedEntry(Object.assign({}, t, { current: t.session_id === ctx.sessionId }), i + 1)).join('\n\n');
}
case 'delete': {
const sid = target();
const old = scheduler.deleteTask(db, sid);
return '已删除 id=' + sid + '(原定 cron="' + old + '")';
}
default:
throw new Error('未知的 op:"' + op + '"。可用:get / list(跨会话全览,每行带 id)/ create(仅当前会话;需 cron_expr、prompt、brief)/ update(需 cron_expr、prompt 至少一个,可选 id)/ delete(可选 id)');
}
}
// profile:用户画像增量维护(op 分派同 schedule 风格)。user 取自会话行,AI 不可指定他人;
// 条件必填/帽子校验全在 user-profile.js(抛错由引擎包成 is_error 回执),停用拒写不拒读。
function toolProfile(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const s = ctx.db.prepare('SELECT user FROM sessions WHERE id = ?').get(ctx.sessionId);
if (!s) throw new Error('会话不存在');
const user = s.user;
switch (op) {
case 'list': {
const p = profile.getProfile(ctx.db, user);
const lines = [
'称谓:' + (p.honorific || '(未记录)'),
'行业:' + (p.industry || '(未记录)'),
'偏好:' + (p.preference || '(未记录)'),
];
if (!p.enabled) lines.push('(该用户已停用画像注入;set/add/remove 会被拒绝)');
lines.push('本会话已注入的快照不会因写入而变;新会话自动携带最新画像。');
return lines.join('\n');
}
case 'set': {
const keys = ['honorific', 'industry'].filter(k => typeof args[k] === 'string');
if (keys.length !== 1) throw new Error('op=set 需要 honorific 或 industry 恰一个字符串参数(偏好标签用 add/remove)');
return profile.setProfileField(ctx.db, user, keys[0], args[keys[0]]);
}
case 'add':
return profile.addProfileTags(ctx.db, user, args.tags);
case 'remove':
return profile.removeProfileTags(ctx.db, user, args.tags);
default:
throw new Error('未知的 op:"' + op + '"。可用:list / set(honorific|industry) / add(tags) / remove(tags)');
}
}
// db:会话本地 SQLite(taskDir/data.db,随会话目录隔离,首次使用自动建库建文件)。
// 连接策略:每次调用 open→用→close,不缓存句柄(会话删目录后不留脏连接);
// 单进程 + better-sqlite3 同步 API,同进程内不存在交叠。busy_timeout 兼容
// terminal/技能里 sqlite3 CLI 的并发访问。
// 读写分离硬校验:stmt.reader 为真(纯读)拒走 exec,写语句拒走 query;
// prepare 天然拒绝多语句,堆叠注入在入口即挡下。错误不返 {"error"} JSON 而是抛出,
// 由 engine 统一包成 "Error: ..." 并置 is_error(本库工具约定,见 engine 调用处)。
// 结构化 insert 与 exec 同义但免手写 SQL/数占位符(批量行是手写 VALUES 数 ? 的重灾区):
// 列名先对 sqlite_master 真实列校验再 quoteIdent 转义,值全部走 ? 绑定。
// update/delete 不做结构化 op(单行 SQL 本身简单、错误率低,且 AND 等值 where 表达力
// 不够还要回退 exec):继续走 exec,入口不拦写语句,兑底通道保持全能力。
// runTaskSql 是本工具与 routes/data-page.js(/api/db/{task_id}/query,页面前端调)共用的
// 唯一 SQL 执行入口:prepare/读写分流/事务/DDL 判定两处同一事实源,不漂移。
const DB_MAX_ROWS = 500; // query 行数上限(docs 要求:防爆上下文)
const DB_MAX_BYTES = 100 * 1024; // query 序列化字节上限
function openTaskDbAt(taskDir) {
fs.mkdirSync(taskDir, { recursive: true });
const db = new Database(path.join(taskDir, 'data.db'));
db.pragma('busy_timeout = 5000');
return db;
}
function openTaskDb(ctx) { return openTaskDbAt(ctx.taskDir); }
// better-sqlite3 不接受 boolean/array/object 绑定;JSON 世界 true/false ↔ SQLite 0/1 是强约定。
// 所有进入绑定位的值(params / rows / set / where)统一过这里。
function dbValue(v, label) {
if (v === null || typeof v === 'string' || typeof v === 'number' || typeof v === 'bigint') return v;
if (typeof v === 'boolean') return v ? 1 : 0;
throw new Error('db: ' + label + ' 值类型不支持:' + (Array.isArray(v) ? 'array' : typeof v) + '(可用:string/number/null/boolean)');
}
function sanitizeDbParams(params) {
if (params == null) return [];
if (!Array.isArray(params)) throw new Error('db: params 必须是数组(按 ? 占位符顺序)');
return params.map((v, i) => dbValue(v, 'params[' + i + ']'));
}
// 表必须存在且取真实列名集合(仅 table,视图不可写);返回的 Set 同时充当列名白名单。
function needTaskTableColumns(db, table) {
const hit = db
.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
.get(table);
if (!hit) throw new Error('db: 表不存在:' + table + '(op=tables 看现有表,op=exec 建新表)');
return new Set(db.pragma('table_info(' + quoteIdent(hit.name) + ')').map(c => c.name));
}
function requireColumns(cols, keys, label) {
const bad = keys.filter(k => !cols.has(k));
if (bad.length) {
throw new Error('db: ' + label + ' 含未知列:' + bad.join(', ') + '(现有列:' + [...cols].join(', ') + ')');
}
}
function quoteIdent(name) {
return '"' + String(name).replace(/"/g, '""') + '"';
}
// BLOB 列(Buffer)直接 JSON.stringify 会展开成 {"type":"Buffer","data":[...]} 天书,换占位符。
function jsonSafeRows(rows) {
return rows.map(row => {
const out = {};
for (const k of Object.keys(row)) {
const v = row[k];
out[k] = Buffer.isBuffer(v) ? '<blob ' + v.length + ' bytes>' : v;
}
return out;
});
}
// 500 行 / 100KB 双上限:未超限返回裸数组;超限改 {rows,...} 信封并附截断说明。
// overflow 由 runTaskSql 的行数截断给出(总行数不再探得,故信封只报 returned_rows 不报 total);
// 字节线在此再收。
function renderQueryResult(rows, overflow) {
let shown = rows;
let truncated = !!overflow;
if (Buffer.byteLength(JSON.stringify(shown, null, 2)) > DB_MAX_BYTES) {
truncated = true;
let bytes = 4; // "[\n]"
const kept = [];
for (const r of shown) {
const s = JSON.stringify(r, null, 2).length + 3; // + 逗号与换行余量
if (bytes + s > DB_MAX_BYTES && kept.length) break;
kept.push(r);
bytes += s;
}
shown = kept;
}
if (!truncated) return JSON.stringify(shown, null, 2);
return JSON.stringify({
rows: shown,
returned_rows: shown.length,
truncated: true,
note: '结果已截断(上限 ' + DB_MAX_ROWS + ' 行或 ' + Math.floor(DB_MAX_BYTES / 1024) + ' KB)。用 WHERE 收窄列/行,或 LIMIT/OFFSET 分页。',
}, null, 2);
}
// 任务库单语句执行的统一入口。mode:'read' 只许读(op=query)| 'write' 只许写(op=exec)|
// 'any' 按 stmt.reader 自动分流(HTTP API,SKILL.md 契约:任意单语句)。
// maxRows>0 时读取走 iterate 到量即停(防大表 SELECT * 全量物化),overflow 处置交调用方:
// 工具截断成信封,API 直接报错引导分页。错误一律抛出,不在此层包装返回形态。
function runTaskSql(taskDir, sql, params, mode, maxRows) {
const text = String(sql || '').trim();
if (!text) throw new Error('db: sql 不能为空');
const db = openTaskDbAt(taskDir);
try {
const stmt = db.prepare(text); // 多语句在此抛错(堆叠注入入口即挡)
const bound = sanitizeDbParams(params);
if (stmt.reader) {
if (mode === 'write') throw new Error('db: op=exec 收到只读语句,读取请用 op=query');
const rows = [];
let overflow = false;
if (maxRows > 0) {
const it = stmt.iterate(...bound);
try {
for (const r of it) {
if (rows.length >= maxRows) { overflow = true; break; }
rows.push(r);
}
} finally { try { it.return(); } catch (_) {} }
} else {
for (const r of stmt.all(...bound)) rows.push(r);
}
return { kind: 'read', rows: jsonSafeRows(rows), overflow };
}
if (mode === 'read') throw new Error('db: op=query 只允许读语句(SELECT 等),写操作请用 op=exec');
db.exec('BEGIN');
try {
const info = stmt.run(...bound);
db.exec('COMMIT');
const verb = text.split(/\s+/)[0].toLowerCase();
const out = (verb === 'create' || verb === 'alter' || verb === 'drop')
? { ok: true }
: { rowsAffected: info.changes, lastInsertRowid: Number(info.lastInsertRowid) };
return { kind: 'write', out };
} catch (err) {
try { db.exec('ROLLBACK'); } catch (_) {}
throw err;
}
} finally {
try { db.close(); } catch (_) {}
}
}
function toolDb(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const sql = String(args.sql || '').trim();
const table = String(args.table || '').trim();
let db;
try {
switch (op) {
case 'exec': {
if (!sql) throw new Error('db: op=exec 缺少必填参数 sql');
const r = runTaskSql(ctx.taskDir, sql, args.params, 'write', 0);
return JSON.stringify(r.out);
}
case 'query': {
if (!sql) throw new Error('db: op=query 缺少必填参数 sql');
const r = runTaskSql(ctx.taskDir, sql, args.params, 'read', DB_MAX_ROWS);
return renderQueryResult(r.rows, r.overflow);
}
case 'insert': {
if (!table) throw new Error('db: op=insert 缺少必填参数 table');
const list = args.rows;
if (!Array.isArray(list)) throw new Error('db: op=insert 缺少必填参数 rows(行对象数组,单行也要包成数组)');
if (!list.length) throw new Error('db: op=insert rows 是空数组,无事可做');
for (let i = 0; i < list.length; i++) {
const r = list[i];
if (!r || typeof r !== 'object' || Array.isArray(r) || !Object.keys(r).length) {
throw new Error('db: op=insert rows[' + i + '] 必须是非空对象 {列名: 值}');
}
}
// 各行 key 必须一致:静默补 NULL 会掩盖模型笔误,宁可点名报错。
const cols = Object.keys(list[0]);
for (let i = 1; i < list.length; i++) {
const ks = Object.keys(list[i]);
if (ks.join('\u0000') !== cols.join('\u0000')) {
throw new Error('db: op=insert 各行 key 必须一致:rows[0]=' + JSON.stringify(cols) +
',rows[' + i + ']=' + JSON.stringify(ks));
}
}
db = openTaskDb(ctx);
requireColumns(needTaskTableColumns(db, table), cols, 'rows');
const sqlIns = 'INSERT INTO ' + quoteIdent(table) + ' (' + cols.map(quoteIdent).join(', ') +
') VALUES (' + cols.map(() => '?').join(', ') + ')';
const stmtIns = db.prepare(sqlIns);
db.exec('BEGIN');
try {
let firstId = null;
for (const r of list) {
const info = stmtIns.run(...cols.map(c => dbValue(r[c], 'rows.' + c)));
if (firstId === null) firstId = Number(info.lastInsertRowid);
}
db.exec('COMMIT');
return JSON.stringify({ inserted: list.length, firstInsertRowid: firstId });
} catch (err) {
try { db.exec('ROLLBACK'); } catch (_) {}
throw err;
}
}
case 'tables': {
db = openTaskDb(ctx);
const names = db
.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
.all().map(r => r.name);
const out = names.map(n => ({ name: n, rows: db.prepare('SELECT COUNT(*) AS c FROM ' + quoteIdent(n)).get().c }));
return JSON.stringify(out, null, 2);
}
case 'schema': {
if (!table) throw new Error('db: op=schema 缺少必填参数 table');
db = openTaskDb(ctx);
// PRAGMA 不支持 ? 绑定:先参数化确认表存在,再用转义标识符拼入(不存在即报错,拼入的必是真实名)。
const hit = db
.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?")
.get(table);
if (!hit) throw new Error('db: 表不存在:' + table);
const cols = db.pragma('table_info(' + quoteIdent(hit.name) + ')');
return JSON.stringify(cols.map(c => ({
name: c.name, type: c.type, notnull: !!c.notnull, dflt_value: c.dflt_value, pk: !!c.pk,
})), null, 2);
}
default:
throw new Error('db: 未知的 op:"' + op + '"。可用:exec(需 sql,params 可选)/ query(需 sql,params 可选)/ insert(需 table、rows)/ tables / schema(需 table)');
}
} finally {
if (db) try { db.close(); } catch (_) {}
}
}
// skill:技能三件套(list_skills/get_skill_info/run_skill)合并后的单工具(op 分派)。
// 同一标识空间(name)+ 同一生命周期(live 扫目录,无常驻状态可增删)→ 合并,
// 依据 docs/tool-design.md §一;技能不是「无持久状态」的动作,run 不必单独成工具。
// input_args 仅 op=run 用且可缺省:runSkill 把 null 视作 {},真正缺哪些字段由
// 各技能 input_schema 校验点名报错(工具层再 gate 一层是双重门槛,无益)。
// visit_url(front matter 可选):页面产物类技能声明访问路径模板,run 成功后在本层拼
// public_link.base_url(与 mint_public_link 同源)追加完整「访问地址」——技能进程跑在
// executor 隔离视图里不知道公网前缀,AI 拿到相对路径就会原样转给用户,而相对路径打不开。
async function runSkillWithVisit(ctx, name, inputArgs) {
const out = await skills.runSkill(ctx, name, inputArgs);
let fm;
try {
fm = skills.parseFrontMatter(await skills.getSkillInfo(ctx, name));
} catch (_) {
return out; // 描述文件异常不该废掉一次成功的 run
}
const tpl = fm && fm.visit_url ? String(fm.visit_url).trim() : '';
if (!tpl) return out;
const rel = tpl.replace(/\{task_id\}/g, ctx.sessionId || path.basename(path.resolve(ctx.taskDir || '')));
const pl = (ctx.cfg && ctx.cfg.public_link) || {};
const base = String(pl.base_url || '').trim().replace(/\/+$/, '');
return out + '\n访问地址:' + (base
? base + rel
: rel + '(站内路径:public_link.base_url 未配置,拼不出公网前缀)');
}
async function toolSkill(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const name = String(args.name || '').trim();
switch (op) {
case 'list':
return JSON.stringify(await skills.listSkills(ctx), null, 2);
case 'get': {
if (!name) throw new Error('op=get 缺少必填参数 name');
return skills.getSkillInfo(ctx, name);
}
case 'run': {
if (!name) throw new Error('op=run 缺少必填参数 name');
return runSkillWithVisit(ctx, name, args.input_args);
}
default:
throw new Error('未知的 op:"' + op + '"。可用:list / get(需 name)/ run(需 name,input_args 可选)');
}
}
// lab:全工具统一入口(元工具,tools 数组收缩到 1 个仍可达内置 + MCP 全部能力)。
// args 为自由对象——目标 schema 定义期不可知(docs/tool-design.md §三 的合法例外),
// 条件校验归内层 handler;错误冒泡不包装(只有一层)。help 是伪工具:不进 HANDLERS,
// 只在本函数早退。默认被全局 tools_deny 屏蔽,仅 lab profile 显式清空 deny 后下发。
async function toolLab(ctx, args) {
const name = String(args.tool || '').trim();
if (!name) throw new Error('lab: 缺少参数 tool。可用:' + listCallableTools().join(', '));
if (name === 'lab') throw new Error('lab: 不允许嵌套调用 lab。');
if (name === 'help') return runLabHelp(args.args);
const inner = args.args;
if (inner != null && (typeof inner !== 'object' || Array.isArray(inner))) {
throw new Error('lab: args 必须是对象(目标工具的键值参数),收到:' + JSON.stringify(inner).slice(0, 80));
}
// 先自查再转发:未知名要带全清单回显(§五 报错回显),executeTool 的兑底文案没这个待遇。
if (!HANDLERS[name] && !mcp.hasTool(name)) {
throw new Error('未知工具 "' + name + '"。可用:' + listCallableTools().join(', '));
}
return executeTool(ctx, name, inner || {});
}
function listCallableTools() {
// help 不在 HANDLERS(伪工具);lab 自身不列(嵌套已被拒,列了只会诱导模型绕圈)。
// MCP 侧用 toolDefinitions() 现成取名——含冲突重命名的 server__ 前缀,与实际可调用名严格一致。
return Object.keys(HANDLERS).filter(n => n !== 'lab')
.concat(mcp.toolDefinitions().map(t => t.function.name));
}
function runLabHelp(args) {
const all = BUILTIN_TOOL_DEFS.concat(mcp.toolDefinitions())
.filter(t => t && t.function && t.function.name !== 'lab');
const target = args && String(args.tool || '').trim();
if (!target) {
return all.map(t => t.function.name + ' — ' + String(t.function.description || '').split('\n')[0].trim()).join('\n');
}
const def = all.find(t => t.function.name === target);
if (!def) throw new Error('未知工具 "' + target + '"。可用:' + all.map(t => t.function.name).join(', '));
return JSON.stringify(def.function, null, 2);
}
// handoff:顾问阶段唯一出口(advising 组合见 config.js)。brief 原样落盘任务目录根 task.md;
// title 直写 sessions.title(交接此刻顾问最懂这单任务,标题以此为准,finalize 的
// maybeGenerateTitle 见非空即跳过);批尾由 engine 广播 title 事件同步已开窗口。
// 切换不在此发生——executeTool 只落盘与回执,runLoopInner 在工具批尾接成功回执触发 enterExecuting
//(其读盘取快照作锚点,幂等防重切)。phase 守卫不可省:「名单外工具照跑」是全局策略,
// 执行期幻觉调用不得覆写修订中的 task.md;reason 枚举与 brief 非空也在此兑底(checkToolArgs 只查必填键)。
async function toolHandoff(ctx, args) {
const sess = ctx.db.prepare('SELECT phase, title_locked FROM sessions WHERE id = ?').get(ctx.sessionId);
if (!sess || sess.phase !== 'advising') return 'Error: 当前不在顾问阶段,handoff 仅在 advising 可用';
const reason = String((args && args.reason) || '');
if (['ready', 'user_skip', 'user_stuck'].indexOf(reason) < 0) {
return 'Error: reason 需为 ready / user_skip / user_stuck 之一';
}
const brief = typeof args.brief === 'string' ? args.brief : '';
if (!brief.trim()) return 'Error: brief 不能为空,任务书需完整带上(user_skip/user_stuck 至少含用户原话与 Missing 清单)';
// 标题清洗对齐 cleanTitle(engine 内函数,executor 反向引用会成环,此处同款口径):
// 压空白 + 截 60;引号剥除交给模型自觉(description 已明说),不做二次加工。
const title = String(args.title || '').replace(/\s+/g, ' ').trim().slice(0, 60);
if (!title) return 'Error: title 不能为空,给出一个概括任务的简洁标题';
const abs = path.join(ctx.taskDir, 'task.md');
await fsp.writeFile(abs, brief, 'utf8');
recordFile(ctx, abs); // 同步 files 元数据表(与 write_file 同轨,任务目录列表/清理逻辑一致)
// task.md 落盘成功后才改标题:切换半途失败不留「有名无书」的残局;
// 用户手动重命名过(title_locked,见 engine.renameSession)则尊重用户的名字,静默跳过。
if (!sess.title_locked) {
ctx.db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(title, Date.now(), ctx.sessionId);
}
// 同批多次 handoff:后写覆盖(last-wins),批尾的切换只发生一次(enterExecuting 幂等)。
// 回执只写事实:成功路径下本回执连同父行一起被存档、不会回到任何模型;
// 读者只有 enterExecuting 放弃/报错后继续 advising 的模型本身(据此自纠),无行为指令可带。
return '已接收交接(reason: ' + reason + '),本批工具跑完后系统将切换到执行阶段。';
}
// recall:长期记忆(工作日记)的回忆入口(定稿 B 方案:极简三 op,描述短不挤占工具位)。
// 日记按会话收口持久存储(memory.js),开场只注入最近 N 条;更早的条目与某次工作的成果文件由本工具按需取。
// 只读数据面:仅能碰本用户的日记与会话(id 同用户校验防互探);link 产出的外链与 mint_public_link 同机制同时效。
function toolRecall(ctx, args) {
const op = String(args.op || '').trim().toLowerCase();
const db = ctx.db;
const me = db.prepare('SELECT user FROM sessions WHERE id = ?').get(ctx.sessionId);
const user = String((me && me.user) || '');
// files/link 共用:解析并校验目标会话(存在 + 同用户 + id 形态),返回 {sid, title, dir}
const resolveSession = () => {
const sid = String(args.id || '').trim();
if (!/^task-[0-9A-Za-z_\-]+$/.test(sid)) throw new Error('需要 id:日记碎片【编号】里的会话 id(形如 task-YYYYMMDD-NNN)');
const s = db.prepare('SELECT id, user, title FROM sessions WHERE id = ?').get(sid);
if (!s) throw new Error('会话 ' + sid + ' 不存在(可能已删除)');
if (String(s.user || '') !== user) throw new Error('无权访问该会话(非当前用户)');
const root = String((ctx.cfg && ctx.cfg.workspace_root) || '');
if (!root) throw new Error('workspace_root 未配置');
return { sid: sid, title: s.title || sid, dir: path.join(root, sid) };
};
switch (op) {
case 'search': {
const q = String(args.query || '').trim();
if (!q) throw new Error('op=search 需要 query(关键词;空格分隔多个词更好,如「身份证 水印」)');
const txt = memory.searchFragments(db, user, q, args.count);
return txt || '日记中无「' + q + '」相关记录。';
}
case 'days': {
const list = memory.daysIndex(db, user);
if (!list.length) return '日记库为空(尚无收口碎片)。';
return '【日记索引】共 ' + list.length + ' 天(新在前):\n' + list.join('\n');
}
case 'day': {
const date = String(args.date || '').trim();
if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new Error('op=day 需要 date(YYYY-MM-DD,先用 op=days 查有哪些天)');
const txt = memory.dayEntry(db, user, date);
return txt ? date + ' 的日记:\n' + txt : date + ' 无日记。';
}
case 'files': {
const t = resolveSession();
let names = [];
try {
names = fs.readdirSync(t.dir, { withFileTypes: true })
.filter(d => d.isFile() && !d.name.startsWith('.'))
.map(d => d.name)
.sort();
} catch (_) {
return '「' + t.title + '」任务目录不存在,无成果文件。';
}
if (!names.length) return '「' + t.title + '」无成果文件。';
const shown = names.slice(0, 80);
return '「' + t.title + '」现存文件(顶层 ' + shown.length + (names.length > shown.length ? '/共 ' + names.length : '') + ' 个):\n'
+ shown.map(n => '- ' + n).join('\n');
}
case 'link': {
const t = resolveSession();
const rel = String(args.path || '').trim();
if (!rel) throw new Error('op=link 需要 path(op=files 清单里的文件名)');
const abs = resolveInTask(t.dir, rel); // 路径沙箱:只允许该会话任务目录内
let st;
try { st = fs.statSync(abs); } catch (_) { throw new Error('文件不存在:' + rel + '(先 op=files 看现存清单)'); }
if (!st.isFile()) throw new Error('不是普通文件:' + rel);
const pl = ctx.cfg && ctx.cfg.public_link;
if (!pl || !pl.base_url) throw new Error('public_link 未配置,无法生成外链');
return pl.base_url + '/p/' + publicFiles.mint({ sessionId: t.sid, rel: rel, ttlMs: pl.ttl_ms });
}
default:
throw new Error('未知的 op:"' + op + '"。可用:search(需 query,可选 count)/ days(日期索引)/ day(需 date)/ files(需 id)/ link(需 id+path)');
}
}
const HANDLERS = {
read_file: toolReadFile,
handoff: toolHandoff,
write_file: toolWriteFile,
edit_file: toolEditFile,
mint_public_link: toolMintPublicLink,
terminal: toolTerminal,
fetch: toolFetch,
schedule: toolScheduleTask,
profile: toolProfile,
recall: toolRecall,
db: toolDb,
skill: toolSkill,
lab: toolLab,
};
// ctx: {sessionId, taskDir, run, cfg, db, vision}
// 返回值一般为字符串;read_file 读图且 ctx.vision 为 true 时返回 {text, image_rel}。
// 内置工具优先;未命中时交给 MCP 注册表(启动时发现的服务工具)。
async function executeTool(baseCtx, name, args) {
const handler = HANDLERS[name];
if (handler) return handler(baseCtx, args || {});
if (mcp.hasTool(name)) return mcp.callTool(name, args || {});
return 'Error: 未知工具 ' + name;
}
module.exports = { executeTool, resolveInTask, recordFile, runTaskSql };