// agent 文件工具写回远端 回归测试(issue #15)。 // // 背景:远程工作区会话里 agent 的 write / edit 走**进程内** ctx.fs(base bundle 挂的是本地 // fs-sandbox),只落本地镜像 —— 用户在远端机器上找不到文件,只能人工 push/scp。 // 修法:包装 ctx.fs 的 writeText / editText —— **原方法照旧调用**(镜像内容、沙箱围栏、 // 写意图语义全不变),成功后把 outcome.after 的同一份内容定向推回远端那个文件。 // // 三层: // A. installFsWriteBridge 行为(假 fs 服务):委托、参数透传、回调内容、错误隔离、恢复 // B. findMirrorRoot(真实文件系统):镜像根识别、嵌套、边界 // C. 接线断言(软注入 ctx.fs、清理恢复、定向推送而非整镜像) import { readFileSync, mkdirSync, writeFileSync, mkdtempSync, rmSync } from 'node:fs' import { tmpdir } from 'node:os' import { join } from 'node:path' const root = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1') const src = readFileSync(root + '/lib/index.js', 'utf8') function grab(name) { const start = src.indexOf(name) if (start < 0) throw new Error(name + ' not found') const declStart = src.lastIndexOf('\n', start) let i = src.indexOf('{', start) let depth = 0 for (; i < src.length; i++) { if (src[i] === '{') depth++ else if (src[i] === '}') { depth--; if (depth === 0) break } } return src.slice(declStart + 1, i + 1) } const api = new Function( 'dirname', 'join', 'existsSync', 'readFileSync', grab('function findMirrorRoot') + '\n' + grab('function installFsWriteBridge') + '\nreturn { findMirrorRoot, installFsWriteBridge };' )( (await import('node:path')).dirname, (await import('node:path')).join, (await import('node:fs')).existsSync, (await import('node:fs')).readFileSync, ) let pass = 0, fail = 0 const check = (cond, label) => { if (cond) { pass++; console.log(' ✓ ' + label) } else { fail++; console.log(' ✗ FAIL: ' + label) } } /** 假 ctx.fs:记录调用,返回可控 outcome。 */ function fakeFs(opts = {}) { const calls = [] const svc = { writeText: async (target, content, expected, signal, policy) => { calls.push({ method: 'writeText', target, content, expected, signal, policy }) if (opts.writeThrows) throw new Error('FS_DENIED') return { operation: 'create', version: 'v1', before: null, after: opts.after !== undefined ? opts.after : content } }, editText: async (target, edit, expected, signal, policy) => { calls.push({ method: 'editText', target, edit, expected, signal, policy }) return { version: 'v2', before: 'old', after: opts.after !== undefined ? opts.after : 'new' } }, processPath: (t) => t.processPath, readText: async () => 'untouched', } return { svc, calls } } console.log('A · installFsWriteBridge 行为') { const { svc, calls } = fakeFs() const written = [] const restore = api.installFsWriteBridge(svc, { onWritten: (p, c) => { written.push([p, c]) } }) check(typeof restore === 'function', '安装成功返回恢复函数') const target = { targetKey: 'k1', displayPath: 'rel/a.md', processPath: '/mirror/w1/docs/a.md' } const out = await svc.writeText(target, 'hello', { kind: 'createIfAbsent' }, 'sig', { mode: 'workspace-write', workspaceRoot: '/mirror/w1' }) check(out && out.after === 'hello', '原 writeText 的返回值原样透传') check(calls.length === 1 && calls[0].content === 'hello', '原方法被调用一次且内容一致') check(calls[0].expected && calls[0].expected.kind === 'createIfAbsent' && calls[0].signal === 'sig' && calls[0].policy.mode === 'workspace-write', '写意图 / signal / sandboxPolicy 原样透传(沙箱语义不变)') check(written.length === 1 && written[0][0] === '/mirror/w1/docs/a.md' && written[0][1] === 'hello', '回调收到(processPath 规范路径, 写入后的内容)') check(calls[0].target === target, 'target 未被伪造(原对象直接传给原方法)') written.length = 0 await svc.editText(target, { oldString: 'a', newString: 'b', replaceAll: false }, { version: 'v1' }, 'sig', { mode: 'workspace-write', workspaceRoot: '/mirror/w1' }) check(written.length === 1 && written[0][1] === 'new', 'editText 用 outcome.after 回调(编辑后的完整内容)') restore() const afterRestore = await svc.writeText(target, 'again') check(written.length === 1, '恢复后不再回调') check(afterRestore.after === 'again', '恢复后原实现仍可用') check(svc.readText !== undefined, '其它方法未被触碰') } console.log('A2 · 边界与错误隔离') { // 写入失败 → 不回调 const { svc } = fakeFs({ writeThrows: true }) const written = [] api.installFsWriteBridge(svc, { onWritten: (p, c) => written.push([p, c]) }) let threw = false try { await svc.writeText({ targetKey: 'k', processPath: '/m/a' }, 'x') } catch (e) { threw = true } check(threw === true, '原写入抛错时异常照旧抛出(不吞)') check(written.length === 0, '原写入失败 → 不回调(不会把失败当成功推)') // 回调抛错 → 不影响写入结果,只告警 const { svc: svc2 } = fakeFs() const warns = [] api.installFsWriteBridge(svc2, { onWritten: () => { throw new Error('ssh down') }, log: { warn: (m) => warns.push(m) } }) const out2 = await svc2.writeText({ targetKey: 'k', processPath: '/m/a' }, 'y') check(out2.after === 'y', '回调失败不影响写入结果(本地写入已成功)') check(warns.length === 1 && /本地镜像已写入/.test(warns[0]), '回调失败只记一条 warn,且说明本地已写入') // 无 processPath 时退回 displayPath const { svc: svc3 } = fakeFs() const seen = [] api.installFsWriteBridge(svc3, { onWritten: (p) => seen.push(p) }) await svc3.writeText({ targetKey: 'k', displayPath: 'D:\\m\\a.md' }, 'z') check(seen[0] === 'D:\\m\\a.md', '无 processPath 时退回 displayPath') // 非法服务 → 安全返回 null check(api.installFsWriteBridge({}, { onWritten: () => {} }) === null, '缺少 writeText → 返回 null(不抛)') check(api.installFsWriteBridge(undefined, { onWritten: () => {} }) === null, '服务缺失 → 返回 null') check(api.installFsWriteBridge(fakeFs().svc, {}) === null, '未提供 onWritten → 返回 null') } console.log('B · findMirrorRoot(真实文件系统)') { const base = mkdtempSync(join(tmpdir(), 'rssh-mirror-')) try { const mirror = join(base, 'wmirror1') mkdirSync(join(mirror, 'docs', 'deep'), { recursive: true }) writeFileSync(join(mirror, '.remote-ssh.json'), JSON.stringify({ profileId: 'p1', host: 'hpc-a.example.com', user: 'u', remotePath: '~/proj' })) const hit = api.findMirrorRoot(join(mirror, 'docs', 'deep', 'a.md')) check(hit && hit.root === mirror, '嵌套深层文件能找到镜像根') check(hit && hit.info.remotePath === '~/proj', '带回 .remote-ssh.json 的内容') check(api.findMirrorRoot(join(base, 'elsewhere', 'x.md')) === null, '非镜像路径 → null') // 标记文件缺少必需字段 → 不算镜像根 const bad = join(base, 'wmirror2') mkdirSync(bad, { recursive: true }) writeFileSync(join(bad, '.remote-ssh.json'), JSON.stringify({ profileId: 'p1' })) check(api.findMirrorRoot(join(bad, 'a.md')) === null, '标记缺 host/user/remotePath → null(不误判)') check(api.findMirrorRoot('') === null && api.findMirrorRoot(undefined) === null, '空路径安全') // 越界深度(镜像根在 9 层以上)→ null(有界,避免病态遍历) let deep = join(base, 'wmirror3') mkdirSync(deep, { recursive: true }) writeFileSync(join(deep, '.remote-ssh.json'), JSON.stringify({ host: 'h', user: 'u', remotePath: '~/p' })) let nested = deep for (let i = 0; i < 9; i++) { nested = join(nested, 'd' + i); mkdirSync(nested, { recursive: true }) } check(api.findMirrorRoot(join(nested, 'a.md')) === null, '超过 8 层 → null(有界)') } finally { rmSync(base, { recursive: true, force: true }) } } console.log('C · 接线') { check(/ctx\.inject\(\["fs"\]/.test(src), '软注入 ctx.fs(缺失时不阻塞插件挂载)') check(/installFsWriteBridge\(svc, \{ onWritten: mirrorWriteToRemote, log: ctx\.logger \}\)/.test(src), '桥接到 mirrorWriteToRemote') check(/if \(restoreFsWrite\) \{ try \{ restoreFsWrite\(\); \}/.test(src), '清理时恢复原方法') check(/const hit = findMirrorRoot\(absPath\);\s*\n\s*if \(!hit\) return;/.test(src), '非镜像路径直接返回(本地工作区零影响)') check(/await remoteWriteFileChunked\(runPooled, p, remoteFile, content\)/.test(src), '走 remoteWriteFileChunked 定向写该文件(小文件内部仍走 remoteWriteFile,>4 MiB 分块)') check(/"mkdir -p " \+ shellQuotePath\(remoteDir\)/.test(src), '写前 mkdir -p 远端父目录(新目录里的新文件)') check(/await runPooled\(p, "mkdir -p/.test(src) && /await remoteWriteFileChunked/.test(src), '两步都在同一池化会话(连接复用)') check(/本地镜像已写入/.test(src), '推送失败时的告警文案说明本地已写入') check(!/remoteSyncUp\(/.test(grab('async function mirrorWriteToRemote')), '不调用整镜像 push(避免用旧镜像覆盖远端其它文件)') } // --------------------------------------------------------------------------- // issue #24:写回桥的失败可见性与护栏 // ① >4 MiB 的内容不再确定性失败(分块 base64 追加 + 远端字节数校验) // ② 每个工作区可关掉写回或排除路径(writeBack / writeBackExclude) // ③ 推送失败默认抛错让模型看见(工具报错是本版 DSH 上唯一的模型可见通道) // --------------------------------------------------------------------------- const chunkApi = new Function( 'dirname', 'join', 'existsSync', 'readFileSync', 'MAX_BYTES', 'shellQuotePath', 'invalidateRemoteCaches', 'syncErrText', 'remoteWriteFile', grab('function remoteWriteFileChunked') + '\n' + grab('function globToRegExp') + '\n' + grab('function matchAnyGlob') + '\nreturn { remoteWriteFileChunked, globToRegExp, matchAnyGlob };' )( (await import('node:path')).dirname, (await import('node:path')).join, (await import('node:fs')).existsSync, (await import('node:fs')).readFileSync, 4 * 1024 * 1024, // 与 lib 里的 MAX_BYTES 一致(下面的载荷要越过它) (s) => "'" + String(s) + "'", () => {}, (e) => String((e && e.message) || e), // 真实的 remoteWriteFile 语义(4 MiB 守卫 + base64 -d 单发)——负向控制要用它 async (runner, p, path, content) => { const c = content !== undefined ? String(content) : '' if (c.length > 4 * 1024 * 1024) return { ok: false, exitCode: -1, stdout: '', stderr: '', error: '写入内容超过 ' + 4 * 1024 * 1024 + ' 字节上限', truncated: false } return runner(p, 'base64 -d > ' + "'" + path + "'", Buffer.from(c, 'utf8').toString('base64'), 4 * 1024 * 1024, true) } ) /** 假 runner:把每次调用的命令与 stdin 记下来,按脚本应答。 */ function fakeRunner(opts = {}) { const calls = [] const fn = async (p, cmd, stdinData) => { calls.push({ cmd, stdin: stdinData === undefined ? '' : String(stdinData) }) if (opts.failAt !== undefined && calls.length === opts.failAt) return { ok: false, exitCode: 1, stdout: '', stderr: 'disk full', error: 'disk full' } if (/^wc -c 4 MiB 不再确定性失败(issue #24 主线)') { // 7 MiB 载荷,含多字节字符:中文 + emoji + 末尾不足 3 字节的尾巴 const base = '数据📊 line\n' const payload = base.repeat(Math.ceil((7 * 1024 * 1024) / base.length)).slice(0, 7 * 1024 * 1024) const bytes = Buffer.byteLength(payload, 'utf8') check(bytes > 4 * 1024 * 1024, '测试载荷确实越过 4 MiB(' + bytes + ' 字节)') // 负向控制:旧的 remoteWriteFile 对同一内容是确定性失败(issue #24 报的就是这个) const legacyRunner = fakeRunner({}) const legacyCall = await (async () => { // 注入的 remoteWriteFile 语义(4 MiB 守卫 + base64 -d 单发) const fn = new Function('runner', 'p', 'path', 'content', 'return (async () => { const c = String(content); if (c.length > 4 * 1024 * 1024) return { ok: false, error: "写入内容超过 " + 4 * 1024 * 1024 + " 字节上限" }; return runner(p, "base64 -d > " + path, Buffer.from(c, "utf8").toString("base64")); })()') return fn(legacyRunner, {}, '/r/big.txt', payload) })() check(legacyCall.ok === false && /4 MiB|上限/.test(String(legacyCall.error) || ''), '负向控制:旧路径对 7 MiB 内容是确定性失败(只落日志,模型看不见)') const runner = fakeRunner({ expectBytes: bytes }) const r = await chunkApi.remoteWriteFileChunked(runner, {}, '/remote/big.txt', payload) check(r.ok === true, '新路径成功(不再因体积失败)') const writes = runner.calls.filter((c) => /^base64 -d /.test(c.cmd)) const expectChunks = Math.ceil(bytes / (3 * 1024 * 1024)) check(writes.length === expectChunks, '分块数 = ceil(字节数 / 3 MiB) = ' + expectChunks + '(按字节切,不是按字符)') check(/^base64 -d > /.test(writes[0].cmd) && writes.slice(1).every((c) => /^base64 -d >> /.test(c.cmd)), '首块用 > 覆盖、后续用 >> 追加') // 关键性质:块大小是 3 的倍数 → 非末块 base64 不带 padding,可直接拼接 check(writes.slice(0, -1).every((c) => !c.stdin.includes('=')), '非末块 base64 无 padding(可直接拼接)') const joined = Buffer.concat(writes.map((c) => Buffer.from(c.stdin, 'base64'))) check(joined.equals(Buffer.from(payload, 'utf8')), '各块解码后拼接的字节与原内容逐字节相同(多字节字符未被劈开)') check(runner.calls.some((c) => /^wc -c ,无分块、无 wc) const small = fakeRunner({}) const rs = await chunkApi.remoteWriteFileChunked(small, {}, '/remote/small.txt', '你好') check(rs.ok === true && small.calls.length === 1 && /^base64 -d > /.test(small.calls[0].cmd), '小文件仍是一次 base64 -d >(行为与 2.4.23 相同,无额外往返)') } console.log('D2 · writeBackExclude 的 glob 语义') { const m = (pats, rel) => chunkApi.matchAnyGlob(pats, rel) check(m(['_patch/**'], '_patch/draft.md') === true, '** 跨目录:_patch/** 命中 _patch/draft.md') check(m(['_patch/**'], '_patch/a/b/c.txt') === true, '** 跨多层目录') check(m(['_patch/**'], 'src/_patch.md') === false, '整路径锚定,不是子串匹配') check(m(['**/*.tmp'], 'a/b/x.tmp') === true && m(['**/*.tmp'], 'x.tmp') === true, '**/*.tmp 命中任意层级(含根层)') check(m(['*.log'], 'run.log') === true && m(['*.log'], 'a/run.log') === false, '* 不跨目录') check(m(['docs/*.md'], 'docs/a.md') === true && m(['docs/*.md'], 'docs/sub/a.md') === false, 'docs/*.md 只匹配一层') check(m(['a/b.txt'], 'a/b.txt') === true && m(['a/b.txt'], 'a/b.txt.bak') === false, '精确路径匹配') check(m(['_patch/'], '_patch/x') === true && m(['_patch/'], '_patch') === true, '结尾带 / 视为目录前缀') check(m(['_patch/'], '_patch2/x') === false, '目录前缀不误伤同名前缀目录(_patch2)') check(m(['?.md'], 'a.md') === true && m(['?.md'], 'ab.md') === false, '? 匹配单个字符') check(m([], 'anything') === false && m(['', ' '], 'x') === false, '空规则不排除任何东西') check(m(['a+b.md'], 'a+b.md') === true && m(['a+b.md'], 'aab.md') === false, '正则元字符按字面处理') } console.log('D3 · 推送失败对模型可见(工具报错)') { // 真实 installFsWriteBridge:标记过的失败必须继续上抛 const { svc } = fakeFs() api.installFsWriteBridge(svc, { onWritten: () => { const e = new Error('本地镜像已写入成功,但同步到远端失败:/r/x.txt — ssh 断开'); e.dshRemoteSshWriteBack = true; throw e }, }) let caught = null try { await svc.writeText({ targetKey: 'k', processPath: '/mirror/w1/a.md' }, 'data') } catch (e) { caught = e } check(caught !== null, '标记过的写回失败会让 writeText 抛错(→ 工具报错 → 模型看得见)') check(caught && /本地镜像已写入成功/.test(caught.message), '错误消息点明本地写入是成功的(模型不会以为本地也没写成)') // 真实文案在源码里(断言实现,而不是断言测试自造的文本) check(/remote_ssh_push 补推/.test(grab('async function mirrorWriteToRemote')), '真实错误文案给出补救路径(remote_ssh_push)') // 未标记的异常仍然只告警(不改变工具行为) const { svc: svc2 } = fakeFs() const warns = [] api.installFsWriteBridge(svc2, { onWritten: () => { throw new Error('别的错') }, log: { warn: (m) => warns.push(m) } }) const ok = await svc2.writeText({ targetKey: 'k', processPath: '/m/a' }, 'y') check(ok.after === 'y' && warns.length === 1, '未标记的异常仍只告警,写入结果照常返回') // 接线:模式开关 + 护栏 check(/writeBackFailure: z\.string\(\)\.default\("error"\)/.test(src), '设置项 writeBackFailure 默认 "error"(可见)') check(/DSH_REMOTE_SSH_WRITEBACK_FAILURE/.test(src), '环境变量可覆盖(现场应急用)') check(/writeBack: z\.boolean\(\)\.default\(true\)/.test(src) && /writeBackExclude: z\.array\(z\.string\(\)\)\.default\(\[\]\)/.test(src), '每个工作区有 writeBack / writeBackExclude(默认不改变旧行为)') const body = grab('async function mirrorWriteToRemote') check(/w\.writeBack === false/.test(body) && /matchAnyGlob\(w\.writeBackExclude, relPath\)/.test(body), '写回前按工作区设置判断开关与排除(命中就完全不推送)') check(/err\.dshRemoteSshWriteBack = true/.test(body) && /writeBackFailureMode\(\) !== "error"/.test(body), '失败默认抛标记错误,可退回只记日志') check(/settingsFace\.read\(\)\.workspaces/.test(body), '按镜像目录匹配工作区设置(不是全局一刀切)') } // --------------------------------------------------------------------------- // E · 护栏 B:写回之前的远端新鲜度检查(issue #24 第二轮验收) // // 举报人的现场:共享集群上最常见的"另一个写入者"是**你自己刚跑完的作业** —— 作业改了远端, // 镜像还是旧版,agent 再写一次就把远端内容静默覆盖了。判据按他的建议**只在远端自己的时间轴上 // 自比**(不与本地 mtime 比,避开跨机时钟偏移与 tar/base64 重写),这里把该判据抽成纯函数验证。 // --------------------------------------------------------------------------- const { existsSync } = await import('node:fs') const guardSrc = src.slice( src.indexOf('function freshnessFile(stateDir)'), src.indexOf('/**\n * 把 glob 模式转成锚定') ) if (!guardSrc) throw new Error('护栏 B 的代码未找到(freshnessFile … freshnessVerdict)') const guardApi = new Function( 'join', 'readFileSync', 'writeFileSync', 'mkdirSync', 'shellQuotePath', 'syncErrText', guardSrc + '\nreturn { freshnessGet, freshnessSet, freshnessForget, freshnessForgetProfile, remoteMtimeInfo, freshnessVerdict, freshnessGuardPlan, applyFreshnessPlan, freshnessGuardCheck };' )( (await import('node:path')).join, readFileSync, writeFileSync, mkdirSync, (s) => "'" + String(s) + "'", (e) => String((e && e.message) || e) ) console.log('E · 护栏 B 判据:三态(没变 / 被改过 / 读不到)') { const same = guardApi.freshnessVerdict('100:200', { ok: true, exists: true, stamp: '100:200' }) check(same.changed === false && same.unknown === false, '记录一致 → 没被改过(照常推送)') const diff = guardApi.freshnessVerdict('100:200', { ok: true, exists: true, stamp: '120:260' }) check(diff.changed === true && /已变/.test(diff.why), 'size:mtime 变了 → 判定"远端被改过"(不推送)') const sizeOnly = guardApi.freshnessVerdict('100:200', { ok: true, exists: true, stamp: '101:200' }) check(sizeOnly.changed === true, '只有 size 变了也算(同秒内改动的兜底;举报人只提了 mtime,size 是白拿的)') const gone = guardApi.freshnessVerdict('100:200', { ok: true, exists: false }) check(gone.changed === true && /不存在/.test(gone.why), '远端这份已消失 → 也算被改过(不静默重建)') const unknown = guardApi.freshnessVerdict('100:200', { ok: false, exists: false, err: 'connection reset' }) check(unknown.changed === false && unknown.unknown === true, '读失败 → 状态未知,**不能**当成被改过(把 flaky 连接变成"拦住写入"是错的)') check(guardApi.freshnessVerdict('', null).changed === false, '没有记录 → 放行(首次推这个路径)') } console.log('E2 · 状态文件(~/.dsh/remote-ssh/writeback-mtimes.json)') { const stateDir = mkdtempSync(join(tmpdir(), 'rssh-fresh-')) try { check(guardApi.freshnessGet(stateDir, 'p1', '/r/a.txt') === '', '没有记录时返回空串') guardApi.freshnessSet(stateDir, 'p1', '/r/a.txt', '100:200') check(guardApi.freshnessGet(stateDir, 'p1', '/r/a.txt') === '100:200', '写入后能读回') check(existsSync(join(stateDir, 'writeback-mtimes.json')), '落在 writeback-mtimes.json(用户可人工检查/删除)') guardApi.freshnessForget(stateDir, 'p1', '/r/a.txt') check(guardApi.freshnessGet(stateDir, 'p1', '/r/a.txt') === '', 'forget 之后该路径没有记录') guardApi.freshnessSet(stateDir, 'p1', '/r/a.txt', '1:2') guardApi.freshnessSet(stateDir, 'p1', '/r/b.txt', '1:3') guardApi.freshnessSet(stateDir, 'p2', '/r/c.txt', '1:4') guardApi.freshnessForgetProfile(stateDir, 'p1') check(guardApi.freshnessGet(stateDir, 'p1', '/r/a.txt') === '' && guardApi.freshnessGet(stateDir, 'p1', '/r/b.txt') === '', 'forgetProfile 清掉该连接的全部记录(push / sync 成功之后用)') check(guardApi.freshnessGet(stateDir, 'p2', '/r/c.txt') === '1:4', '不碰别的连接的记录(负向控制)') writeFileSync(join(stateDir, 'writeback-mtimes.json'), '{ not json', 'utf8') check(guardApi.freshnessGet(stateDir, 'p1', '/r/a.txt') === '', '状态文件损坏 → 当作没有记录(不抛、不挡写入)') check(guardApi.freshnessGet(join(stateDir, 'no-such-dir'), 'p9', '/r/x') === '', '状态目录不存在 → 空串(不抛)') } finally { rmSync(stateDir, { recursive: true, force: true }) } } console.log('E3 · remoteMtimeInfo:三态由真实 stat 输出决定') { const runnerOf = (out) => async () => ({ ok: out.ok, exitCode: out.ok ? 0 : 1, stdout: out.stdout || '', stderr: out.stderr || '', error: out.error || '' }) const good = await guardApi.remoteMtimeInfo(runnerOf({ ok: true, stdout: '5242919 1760000000\n' }), {}, '/r/big.bin') check(good.ok === true && good.exists === true && good.stamp === '5242919:1760000000', '正常输出 → size:mtime 解析正确') const miss = await guardApi.remoteMtimeInfo(runnerOf({ ok: false, stderr: "stat: cannot statx '/r/gone': No such file or directory" }), {}, '/r/gone') check(miss.ok === true && miss.exists === false, '远端没有这个文件 → exists:false(这才是"被改过",不是"读不到")') const err = await guardApi.remoteMtimeInfo(runnerOf({ ok: false, stderr: 'ssh: connect to host x port 22: Connection refused' }), {}, '/r/a') check(err.ok === false && err.exists === false, '连接失败 → ok:false(状态未知 → 调用方放行)') const boom = await guardApi.remoteMtimeInfo(async () => { throw new Error('socket hang up') }, {}, '/r/a') check(boom.ok === false && /socket hang up/.test(boom.err), 'runner 抛错 → 也归为"状态未知",不崩') let seen = '' await guardApi.remoteMtimeInfo(async (p, cmd) => { seen = cmd; return { ok: true, stdout: '1 2' } }, {}, '/r/big.bin') check(seen === "stat -c'%s %Y' '/r/big.bin'", '命令形状与本插件既有的 stat 一致:' + seen) } console.log('E4 · 接线:查→推→记,且 push/sync/显式写之后忘掉记录') { const iCheck = src.indexOf('await freshnessGuardCheck({') const iWrite = src.indexOf('remoteWriteFileChunked(runPooled, p, remoteFile, content)') const iRecord = src.indexOf('freshnessSet(wrapperDir, p.id, remoteFile, after.stamp)') check(iCheck > 0 && iCheck < iWrite, '推送**之前**先查(顺序:查 → 推)') check(iRecord > iWrite, '推送**成功之后**才记录(顺序:推 → 记)') const guardPlanSrc = grab('function freshnessGuardPlan') check(/action: "block"/.test(guardPlanSrc) && /没有推送到远端/.test(guardPlanSrc) && /remote_ssh_sync 把远端拉下来比对/.test(guardPlanSrc), '被改过时走"不推送"分支,且真实文案给出 sync / push 两条出路(文案在纯函数里,E5 直接断言它的内容)') check((src.match(/freshnessForgetProfile\(wrapperDir, p\.id\)/g) || []).length === 4, 'push/sync 成功后都清记录(工具 + API 两条路各两处 = 4)') check(/freshnessForget\(wrapperDir, p\.id, args\.path\)/.test(src), 'API writeFile 成功 → 忘掉该路径的记录') check(/freshnessForget\(wrapperDir, tc\.profile\.id, rp\)/.test(src), 'remote_ssh_write 成功 → 忘掉该路径的记录') check(/freshnessForget\(wrapperDir, profile\.id, rp\)/.test(src), '文件面板保存成功 → 忘掉该路径的记录') check(/else freshnessForget\(wrapperDir, p\.id, remoteFile\)/.test(src), '推送成功但读不到状态 → 不留陈旧记录') check(/writeBackFreshness: z\.boolean\(\)\.default\(true\)/.test(src), '设置项 writeBackFreshness 默认**开**') check(/DSH_REMOTE_SSH_WRITEBACK_FRESHNESS/.test(src), '环境变量可强制开关') const body = grab('async function mirrorWriteToRemote') check(/applyFreshnessPlan\(plan\)/.test(body) && /if \(guard\.err\) throw guard\.err/.test(body) && /if \(!guard\.pushed\) return/.test(body), '接线只剩三行:抛 / 拦 / 放行(判断都在纯函数里,行为断言见 E5)') check(/err\.dshRemoteSshWriteBack = true/.test(grab('function applyFreshnessPlan')), '拦截用同一套标记错误(否则会被写入桥当普通错误吞掉)') } console.log('E5 · 护栏 B 的处置:三态 × 两种失败模式(举报人标为"未覆盖"的那条行为)') { // ① 判定 + 文案:纯函数,直接跑 const noRec = guardApi.freshnessGuardPlan('', null, 'error', '/r/a.txt') check(noRec.action === 'push' && !noRec.logLine && !noRec.message, '没有记录 → 推,且不产生任何文案(不打扰)') const same = guardApi.freshnessGuardPlan('100:200', { ok: true, exists: true, stamp: '100:200' }, 'error', '/r/a.txt') check(same.action === 'push' && same.fail === false, '记录一致 → 推') const unknown = guardApi.freshnessGuardPlan('100:200', { ok: false, exists: false, err: 'connection reset' }, 'error', '/r/a.txt') check(unknown.action === 'push' && /无法确认远端状态/.test(unknown.logLine) && !unknown.message, '读失败 → 仍然推,只有一行日志("读不到"绝不等于"被改过")') const changedErr = guardApi.freshnessGuardPlan('79:1791796084', { ok: true, exists: true, stamp: '117:1791796207' }, 'error', '/_wbB/guard.txt') check(changedErr.action === 'block' && changedErr.fail === true, '被改过 + error 模式 → 拦住,并标记"要让模型看见"') check(changedErr.message.includes('79:1791796084') && changedErr.message.includes('117:1791796207'), '报告同时给出"上次记录"与"现在读到"两个具体数值(接收方不用自己回头算)') check(/远端文件: \/_wbB\/guard\.txt/.test(changedErr.message), '报告点明是哪个远端文件') check(/没有推送到远端/.test(changedErr.message) && /remote_ssh_sync/.test(changedErr.message) && /remote_ssh_push/.test(changedErr.message), '报告说明"没推送"并给出 sync / push 两条出路') const changedLog = guardApi.freshnessGuardPlan('79:1791796084', { ok: true, exists: true, stamp: '117:1791796207' }, 'log', '/r/a.txt') check(changedLog.action === 'block' && changedLog.fail === false && changedLog.message.length > 0, 'log 模式 → 仍然拦(不推送),但**不抛** —— 这就是"工具应当返回成功"那条行为') const gone = guardApi.freshnessGuardPlan('1:2', { ok: true, exists: false }, 'error', '/r/gone') check(gone.action === 'block' && /不存在/.test(gone.message), '远端这份已被删除 → 也拦(不静默重建)') // ② 处置:把 plan 变成调用方的动作 const okPlan = guardApi.applyFreshnessPlan({ action: 'push' }) check(okPlan.pushed === true && okPlan.err === null, 'push → 照常推送、无错误对象') const logPlan = guardApi.applyFreshnessPlan(changedLog) check(logPlan.pushed === false && logPlan.err === null, '★ log 模式被拦 → 不推送、但**不产生错误对象**(写回桥因此不抛,工具照常返回成功)') const errPlan = guardApi.applyFreshnessPlan(changedErr) check(errPlan.pushed === false && !!errPlan.err && errPlan.err.dshRemoteSshWriteBack === true, '★ error 模式被拦 → 产生带标记的错误(否则写回桥会把它当普通错误吞掉)') check(/没有推送到远端/.test(errPlan.err.message) && /guard\.txt/.test(errPlan.err.message), '抛出去的错误带着完整报告') check(guardApi.applyFreshnessPlan(null).pushed === true, '没有 plan(护栏关着)→ 照常推送(负向控制)') // ③ 整条链:注入假 runner + 真状态文件 —— 读记录 → stat → 判定 → 记日志 → 处置 const stateDir = mkdtempSync(join(tmpdir(), 'rssh-guard-')) try { const runnerOf = (out) => async () => ({ ok: out.ok, exitCode: out.ok ? 0 : 1, stdout: out.stdout || '', stderr: out.stderr || '', error: '' }) const logs = [] const sink = (m) => { logs.push(m) } const call = (over) => guardApi.freshnessGuardCheck(Object.assign({ runner: runnerOf({ ok: true, stdout: '117 1791796207' }), profile: { id: 'p1' }, stateDir, profileId: 'p1', remoteFile: '/r/guard.txt', mode: 'error', log: sink }, over || {})) guardApi.freshnessSet(stateDir, 'p1', '/r/guard.txt', '79:1791796084') const r1 = await call() check(r1.action === 'block' && guardApi.applyFreshnessPlan(r1).err !== null, '整链①:远端变了 + error 模式 → 拦下并报错') check(logs.length === 1 && /护栏 B/.test(logs[0]), '整链①:日志里有一条"不推送(护栏 B)"') check(logs.every((l) => typeof l === 'string' && l.length > 0), '整链①:日志都是非空字符串(不会往日志里塞对象)') logs.length = 0 const r2 = await call({ mode: 'log' }) const a2 = guardApi.applyFreshnessPlan(r2) check(r2.action === 'block' && a2.pushed === false && a2.err === null, '整链②:同一条记录 + log 模式 → 不推送、不抛(本地写入照常成功)') check(logs.length === 2 && /remote_ssh_push/.test(logs[1]), '整链②:log 模式下长文案(含补救步骤)落进日志,而不是"连报告都没有"') logs.length = 0 const r3 = await call({ runner: runnerOf({ ok: false, stderr: 'ssh: connect to host x port 22: Connection refused' }) }) check(r3.action === 'push' && guardApi.applyFreshnessPlan(r3).pushed === true, '整链③:stat 读失败 → 照常推送') check(logs.length === 1 && /仍推送/.test(logs[0]), '整链③:但留一行"无法确认远端状态"的日志') let called = 0 const r4 = await call({ remoteFile: '/r/never-seen.txt', runner: async () => { called++; return { ok: true, stdout: '1 2' } } }) check(r4.action === 'push' && called === 0, '整链④:没有记录 → 放行,且**不花那次 SSH 往返**(runner 一次都没被调用)') guardApi.freshnessSet(stateDir, 'p1', '/r/guard.txt', '79:1791796084') logs.length = 0 const r5 = await call({ runner: runnerOf({ ok: true, stdout: '79 1791796084' }) }) check(r5.action === 'push' && logs.length === 0, '整链⑤:远端没变 → 推,且不产生任何日志(安静路径)') } finally { rmSync(stateDir, { recursive: true, force: true }) } // ④ 不变量(与上面的"具体输入 → 具体期望"互补:这里钉的是**矩阵上必须成立的关系**, // 将来若有人为了"更安全"把未知态也拦下、或让模式渗进判据,这里会直接红) { const prevs = ['', '100:200'] const befores = [ { ok: true, exists: true, stamp: '100:200' }, // 没变 { ok: true, exists: true, stamp: '120:260' }, // 变了 { ok: true, exists: false, err: 'No such file' }, // 远端已消失 { ok: false, exists: false, err: 'connection reset' } // 读失败 ] let n = 0, onlyChangedBlocks = true, failOnlyOnError = true, quietWhenSame = true, applySelfConsistent = true for (const prev of prevs) for (const before of befores) for (const mode of ['error', 'log']) { n++ const v = guardApi.freshnessVerdict(prev, before) const plan = guardApi.freshnessGuardPlan(prev, before, mode, '/r/x.txt') if ((plan.action === 'block') !== v.changed) onlyChangedBlocks = false if (plan.fail && mode !== 'error') failOnlyOnError = false if (!v.changed && !v.unknown && (plan.logLine || plan.message)) quietWhenSame = false const a = guardApi.applyFreshnessPlan(plan) if ((a.err !== null) !== !!plan.fail) applySelfConsistent = false if (a.err && a.err.dshRemoteSshWriteBack !== true) applySelfConsistent = false } check(n === 16, '不变量矩阵覆盖 ' + n + ' 组(2 种记录 × 4 种远端状态 × 2 种模式)') check(onlyChangedBlocks, '不变量:**只有**"被改过"才可能拦(未知/未变一律推)') check(failOnlyOnError, '不变量:fail 只出现在 error 模式(log 模式永不把失败交给模型)') check(quietWhenSame, '不变量:远端没变时完全安静(不产生日志与报告)') check(applySelfConsistent, '不变量:apply 与 plan 自洽,且错误一定带标记') } } console.log(`\n结果: ${pass} 通过, ${fail} 失败`) process.exit(fail ? 1 : 0)