carlos-flow 2.12.7 → 2.12.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AGENTS.md +5 -5
- package/CHANGELOG.md +663 -660
- package/README.en.md +29 -0
- package/README.md +39 -0
- package/README.zh.md +39 -0
- package/TRIGGER_GUIDE.md +2 -2
- package/bridge/mcp-bridge.js +203 -203
- package/check-all.sh +0 -0
- package/ghost.json +1 -7
- package/package.json +114 -114
- package/plugins/carlos-flow-trigger.js +215 -215
- package/scripts/check-no-dead-handler.mjs +87 -87
- package/scripts/check-templates.mjs +126 -126
- package/scripts/clean-readme-noise.mjs +53 -53
- package/scripts/install-hooks.mjs +166 -166
- package/scripts/lang-audit.mjs +172 -172
- package/scripts/mutation-check.mjs +483 -483
- package/scripts/release.mjs +6 -6
- package/scripts/sync-readme.mjs +102 -102
- package/scripts/verify-activation-e2e.sh +55 -55
- package/src/card.js +296 -296
- package/src/commander.js +9 -9
- package/src/dispatch.js +750 -557
- package/src/index.js +1808 -1713
- package/src/protocol.js +95 -95
- package/src/state.js +930 -930
- package/src/trigger.js +909 -909
package/src/state.js
CHANGED
|
@@ -1,931 +1,931 @@
|
|
|
1
|
-
// state.js — Carlos 工作流:持久化 / 审计 / quote 数据源(Node ESM,零外部依赖)
|
|
2
|
-
import fs from "node:fs";
|
|
3
|
-
import path from "node:path";
|
|
4
|
-
import os from "node:os";
|
|
5
|
-
import { spawnSync } from "node:child_process";
|
|
6
|
-
import { createHash, createHmac } from "node:crypto";
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
// 展开路径里的 `~`(家目录)。
|
|
10
|
-
// 背景:README 让用户把 CARLOS_FLOW_HOME 写成 `~/.carlos-flow`,但此前**没有展开** ——
|
|
11
|
-
// path.normalize("~/.carlos-flow") 只是把斜杠改成反斜杠,路径仍是**字面量**,
|
|
12
|
-
// 于是状态/审计链被写到「当前工作目录下的一个名叫 ~ 的目录」里(Windows 实测
|
|
13
|
-
// FLOW_HOME = ~\.carlos-flow),位置诡异、极易丢失。
|
|
14
|
-
// 现在统一展开:`~` → homedir,`~/x` 与 `~\x` → homedir/x。
|
|
15
|
-
export function expandHome(p) {
|
|
16
|
-
if (typeof p !== "string" || p === "") return p;
|
|
17
|
-
if (p === "~") return os.homedir();
|
|
18
|
-
if (p.startsWith("~/") || p.startsWith("~\\")) {
|
|
19
|
-
return path.join(os.homedir(), p.slice(2));
|
|
20
|
-
}
|
|
21
|
-
return p;
|
|
22
|
-
}
|
|
23
|
-
|
|
24
|
-
// 审计链的「链起点」占位值:64 个 0。
|
|
25
|
-
// 全零 prevHash = 「这条记录开启一条新链」,是合法的链首标记,
|
|
26
|
-
// 不是「校验失败」的证据 —— 早期版本写入器跨天不回连时就是这么写的。
|
|
27
|
-
const ZERO_HASH = "0".repeat(64);
|
|
28
|
-
|
|
29
|
-
export const FLOW_HOME = path.normalize(
|
|
30
|
-
expandHome(process.env.CARLOS_FLOW_HOME) || path.join(os.homedir(), ".carlos-flow")
|
|
31
|
-
);
|
|
32
|
-
export const AUDIT_DIR = path.join(FLOW_HOME, "gate-audit");
|
|
33
|
-
export const RUNS_DIR = path.join(FLOW_HOME, "gate-state", "runs");
|
|
34
|
-
|
|
35
|
-
// OpenCode 会话库路径:环境变量优先,回落到跨平台默认
|
|
36
|
-
// OPENCODE_DB_PATH / OPENCODE_DB 与插件侧同一套约定
|
|
37
|
-
// ~ 路径同样需要展开(Windows PowerShell 下 CARLOS_OPENCODE_DB=~/.opencode 会字面写入)
|
|
38
|
-
const OPENCODE_DB = path.normalize(
|
|
39
|
-
expandHome(process.env.OPENCODE_DB_PATH) ||
|
|
40
|
-
expandHome(process.env.OPENCODE_DB) ||
|
|
41
|
-
expandHome(process.env.CARLOS_OPENCODE_DB) ||
|
|
42
|
-
path.join(os.homedir(), ".local", "share", "opencode", "opencode.db")
|
|
43
|
-
);
|
|
44
|
-
|
|
45
|
-
// OpenCode 会话库的**候选路径**(按平台习惯不同,取第一个存在的)。
|
|
46
|
-
// 背景:原先只写死 XDG 路径 ~/.local/share/opencode/opencode.db —— 那是 Linux 的约定。
|
|
47
|
-
// macOS 上 OpenCode 实际落在 ~/Library/Application Support/opencode/,
|
|
48
|
-
// Windows 上落在 %APPDATA%\opencode\ —— 只探 XDG 路径的话,
|
|
49
|
-
// macOS/Windows 用户会**永远拿不到用户原话**,导致 quote 锚点校验直接失败、卡片无法提交。
|
|
50
|
-
// 环境变量优先(显式指定时不做任何猜测)。
|
|
51
|
-
const OPENCODE_DB_CANDIDATES = (() => {
|
|
52
|
-
const envPath = process.env.OPENCODE_DB_PATH || process.env.OPENCODE_DB || process.env.CARLOS_OPENCODE_DB;
|
|
53
|
-
if (envPath) return [path.normalize(envPath)];
|
|
54
|
-
const home = os.homedir();
|
|
55
|
-
const rel = ["opencode", "opencode.db"];
|
|
56
|
-
const candidates = [];
|
|
57
|
-
// XDG 约定(Linux,以及部分 macOS 配置)
|
|
58
|
-
candidates.push(path.join(home, ".local", "share", ...rel));
|
|
59
|
-
// macOS 原生
|
|
60
|
-
candidates.push(path.join(home, "Library", "Application Support", ...rel));
|
|
61
|
-
// Windows(APPDATA)
|
|
62
|
-
const appData = process.env.APPDATA;
|
|
63
|
-
if (appData) candidates.push(path.join(appData, ...rel));
|
|
64
|
-
// Windows(无 APPDATA 时的兜底)
|
|
65
|
-
candidates.push(path.join(home, "AppData", "Roaming", ...rel));
|
|
66
|
-
// 去重(保持顺序)
|
|
67
|
-
return [...new Set(candidates.map((p) => path.normalize(p)))];
|
|
68
|
-
})();
|
|
69
|
-
|
|
70
|
-
// 选出第一个真实存在的候选;都不存在则返回 null(不抛错,降级为“无历史消息”)。
|
|
71
|
-
function resolveOpenCodeDb() {
|
|
72
|
-
for (const p of OPENCODE_DB_CANDIDATES) {
|
|
73
|
-
try {
|
|
74
|
-
if (p && fs.existsSync(p)) return p;
|
|
75
|
-
} catch {
|
|
76
|
-
/* ignore */
|
|
77
|
-
}
|
|
78
|
-
}
|
|
79
|
-
return null;
|
|
80
|
-
}
|
|
81
|
-
|
|
82
|
-
function localDate() {
|
|
83
|
-
const d = new Date();
|
|
84
|
-
const mm = String(d.getMonth() + 1).padStart(2, "0");
|
|
85
|
-
const dd = String(d.getDate()).padStart(2, "0");
|
|
86
|
-
return `${d.getFullYear()}-${mm}-${dd}`;
|
|
87
|
-
}
|
|
88
|
-
|
|
89
|
-
export function sanitizeId(s) {
|
|
90
|
-
const v = String(s || "").replace(/[^A-Za-z0-9_.-]/g, "_");
|
|
91
|
-
if (v === "") return "unknown";
|
|
92
|
-
// 路径穿越防护:拒绝包含 .. 的 ID
|
|
93
|
-
if (v.includes("..")) {
|
|
94
|
-
throw new Error(`invalid session id (path traversal detected): ${s}`);
|
|
95
|
-
}
|
|
96
|
-
return v;
|
|
97
|
-
}
|
|
98
|
-
|
|
99
|
-
// 当前状态文件结构版本号。
|
|
100
|
-
// 改动 defaultState() 的**字段结构**时,必须 +1 并在 migrate() 里加一条迁移。
|
|
101
|
-
export const CURRENT_SCHEMA_VERSION = 4;
|
|
102
|
-
|
|
103
|
-
/**
|
|
104
|
-
* 迁移旧版本的状态文件。
|
|
105
|
-
*
|
|
106
|
-
* 逐版本迁移,每一步都只处理「从 vN 到 vN+1」的差异,
|
|
107
|
-
* 保证任何历史版本都能一路迁到当前版本(不跳步)。
|
|
108
|
-
*
|
|
109
|
-
* v0 → v1:最早的版本没有 schemaVersion 字段(等于 v0)。
|
|
110
|
-
* · 补上 schemaVersion
|
|
111
|
-
* · dispatch_baseline 早期不存在 → 补空数组(无基线时裁定走全量判定,更保守)
|
|
112
|
-
*
|
|
113
|
-
* v1 → v2:新增 last_falsify(负对照记录)。
|
|
114
|
-
* · 旧状态没有这个字段 → 补 null(表示「还没做负对照」,裁定会拒绝 PASS)
|
|
115
|
-
*
|
|
116
|
-
* v2 → v3:新增 audit_axes / audit_axes_ts(双轴审查证据)。
|
|
117
|
-
* · 旧状态没有这两个字段 → 补默认结构(两轴均为 null = 尚未审查,裁定会拒绝 PASS)
|
|
118
|
-
* · audit_axes 存在但结构不全时也在此补齐,避免读到半初始化对象
|
|
119
|
-
*
|
|
120
|
-
* v3 → v4:新增 verdict_role(本条 PASS 是谁落的)。
|
|
121
|
-
* · 旧状态没有这个字段 → 补 null(仅影响可观测性,不影响门禁判定)
|
|
122
|
-
*/
|
|
123
|
-
export function migrate(parsed) {
|
|
124
|
-
if (!parsed || typeof parsed !== "object") return parsed;
|
|
125
|
-
let v = Number(parsed.schemaVersion);
|
|
126
|
-
if (!Number.isInteger(v) || v < 0) v = 0; // 无版本号 → 当作 v0
|
|
127
|
-
const out = { ...parsed };
|
|
128
|
-
|
|
129
|
-
if (v < 1) {
|
|
130
|
-
// v0 → v1
|
|
131
|
-
if (!Array.isArray(out.dispatch_baseline)) out.dispatch_baseline = [];
|
|
132
|
-
if (!Array.isArray(out.activation_pending)) out.activation_pending = [];
|
|
133
|
-
if (typeof out.activation_activated !== "boolean") out.activation_activated = false;
|
|
134
|
-
v = 1;
|
|
135
|
-
}
|
|
136
|
-
|
|
137
|
-
if (v < 2) {
|
|
138
|
-
// v1 → v2
|
|
139
|
-
if (out.last_falsify === undefined) out.last_falsify = null;
|
|
140
|
-
v = 2;
|
|
141
|
-
}
|
|
142
|
-
|
|
143
|
-
if (v < 3) {
|
|
144
|
-
// v2 → v3
|
|
145
|
-
if (!out.audit_axes || typeof out.audit_axes !== "object") {
|
|
146
|
-
out.audit_axes = { standards: null, spec: null };
|
|
147
|
-
} else {
|
|
148
|
-
out.audit_axes = {
|
|
149
|
-
standards: out.audit_axes.standards || null,
|
|
150
|
-
spec: out.audit_axes.spec || null,
|
|
151
|
-
};
|
|
152
|
-
}
|
|
153
|
-
if (typeof out.audit_axes_ts !== "number") out.audit_axes_ts = 0;
|
|
154
|
-
v = 3;
|
|
155
|
-
}
|
|
156
|
-
|
|
157
|
-
if (v < 4) {
|
|
158
|
-
// v3 → v4
|
|
159
|
-
if (out.verdict_role === undefined) out.verdict_role = null;
|
|
160
|
-
v = 4;
|
|
161
|
-
}
|
|
162
|
-
|
|
163
|
-
out.schemaVersion = CURRENT_SCHEMA_VERSION;
|
|
164
|
-
return out;
|
|
165
|
-
}
|
|
166
|
-
|
|
167
|
-
export function defaultState() {
|
|
168
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
169
|
-
// 状态文件结构版本号。
|
|
170
|
-
// 为什么需要:早先靠 {...defaultState(), ...parsed} 做防御性合并,
|
|
171
|
-
// 但**没有版本号** —— 将来改字段名(如 bypass_ts → bypass_at)时,
|
|
172
|
-
// 老用户的 state.json 里那个旧字段会被当成「未知字段」静默丢弃,
|
|
173
|
-
// 表现为「免检没清零」「待补项丢失」这类**很难定位**的退化。
|
|
174
|
-
// 加了版本号 + migrate(),旧状态会被**显式迁移**而不是静默降级。
|
|
175
|
-
schemaVersion: CURRENT_SCHEMA_VERSION,
|
|
176
|
-
card: null,
|
|
177
|
-
card_ts: 0,
|
|
178
|
-
tier: "read_only",
|
|
179
|
-
task_id: null,
|
|
180
|
-
dispatch_count: 0,
|
|
181
|
-
claimed: false,
|
|
182
|
-
claimed_role: null,
|
|
183
|
-
write_files: 0,
|
|
184
|
-
last_user_ts: 0,
|
|
185
|
-
bypass: false,
|
|
186
|
-
bypass_ts: 0,
|
|
187
|
-
verdict: null,
|
|
188
|
-
completed_ok: false,
|
|
189
|
-
stale: false,
|
|
190
|
-
// 智能触发引擎激活占位卡时尚待补齐的字段。
|
|
191
|
-
// 非空时 flow_claim / flow_dispatch 会拒绝派发,防止空卡片被直接派发。
|
|
192
|
-
activation_pending: [],
|
|
193
|
-
// 该会话是否曾被智能触发引擎激活过(单调,只增不减)。
|
|
194
|
-
// 闸门状态由「卡片内容 + 此标记」幂等派生,不再依赖上一轮的 pending 传递,
|
|
195
|
-
// 这样跨进程并发写入也不会出现「卡片为空却 pending=[]」的矛盾组合。
|
|
196
|
-
activation_activated: false,
|
|
197
|
-
// 派发时记录的工作区改动基线(文件路径数组)。
|
|
198
|
-
// 用途:裁定前用「当前改动 - 基线」算出**本次执行引入的**改动,
|
|
199
|
-
// 再与卡片 scope 比对 —— 这样既能拦住越界,又不会把用户自己原有的
|
|
200
|
-
// 未提交改动误判为越界。没有基线时退化为全量判定(更保守,fail-closed)。
|
|
201
|
-
dispatch_baseline: [],
|
|
202
|
-
// 负对照记录(flow_falsify 写入)。
|
|
203
|
-
// 为什么需要:只看 exitCode===0 时,`verify.cmd` 可以是 `|| true` / `echo ok`
|
|
204
|
-
// 这类**空测试** —— 改动前后都退 0,门禁却以为「验证通过了」。
|
|
205
|
-
// 负对照要求:改动前必须失败、改动后必须通过,才证明这个测试真的在测本次改动。
|
|
206
|
-
// null = 还没做负对照(此时 flow_verdict 拒绝 PASS)。
|
|
207
|
-
last_falsify: null,
|
|
208
|
-
// 双轴审查证据(flow_audit_submit 写入)。
|
|
209
|
-
// 结构:{ standards: {verdict,findings,evidence,card_ts,ts} | null, spec: {...} | null }
|
|
210
|
-
//
|
|
211
|
-
// 为什么按轴绑定 card_ts,而不是只用一个全局时间戳:
|
|
212
|
-
// 两轴是**分两次**提交的。卡A提交 standards → 换新卡B → 只补 spec,
|
|
213
|
-
// 此时全局时间戳已被刷新到卡B之后,单看时间戳会放行,而 standards
|
|
214
|
-
// 仍是卡A的结论 —— 「两轴跨卡拼接」。绑定 card_ts 后,换卡即两轴全失效。
|
|
215
|
-
audit_axes: { standards: null, spec: null },
|
|
216
|
-
// 两轴最后提交时间(审计链留痕用;不参与冒充校验,校验看 card_ts)。
|
|
217
|
-
audit_axes_ts: 0,
|
|
218
|
-
// 本条裁定是谁落的("auditor" | "executor" | null)。
|
|
219
|
-
// 与 claimed_role 的区别:claimed_role 是「会话最近 claim 的角色」(可能已过期),
|
|
220
|
-
// verdict_role 是「实际写下这条裁定时传进来的 role」,直接回答「这条 PASS 是谁落的」。
|
|
221
|
-
// 审计流水里也有 role,但那是日志;这是状态层的持久记录,可用 flow_status 直接查。
|
|
222
|
-
verdict_role: null,
|
|
223
|
-
};
|
|
224
|
-
}
|
|
225
|
-
|
|
226
|
-
export function loadState(sid) {
|
|
227
|
-
const file = path.join(RUNS_DIR, sanitizeId(sid), "state.json");
|
|
228
|
-
|
|
229
|
-
// 读失败必须区分「真的没有」与「暂时读不到」。
|
|
230
|
-
//
|
|
231
|
-
// 背景(2026-11-13 实测):旧实现把**任何**读/解析失败都当成「状态不存在」,
|
|
232
|
-
// 返回 defaultState()。而 saveState 用的是 tmp+rename,
|
|
233
|
-
// 在 Windows 上 rename 与其他进程的 readFileSync 存在竞争窗口(EBUSY/EPERM),
|
|
234
|
-
// 读失败 → prev 退化成默认值 → activation_activated 丢成 false →
|
|
235
|
-
// 紧接着的写入把「占位卡的 pending=[三项]」覆盖成「普通卡的 pending=[]」
|
|
236
|
-
// → **激活闸门被绕过**。
|
|
237
|
-
// 这正是并发测试「零泄漏」偶发失败的根因(实测 370 轮里漏 1)。
|
|
238
|
-
//
|
|
239
|
-
// 现在:只有「文件不存在」才返回默认值;
|
|
240
|
-
// 瞬时错误先重试;仍失败则**报错**(fail-closed),
|
|
241
|
-
// 绝不静默把一个有闸门的状态当成无闸门的状态。
|
|
242
|
-
let raw = null;
|
|
243
|
-
let lastErr = null;
|
|
244
|
-
for (let attempt = 0; attempt < 5; attempt++) {
|
|
245
|
-
try {
|
|
246
|
-
raw = fs.readFileSync(file, "utf8");
|
|
247
|
-
lastErr = null;
|
|
248
|
-
break;
|
|
249
|
-
} catch (e) {
|
|
250
|
-
if (e.code === "ENOENT") return defaultState(); // 真的没有
|
|
251
|
-
lastErr = e;
|
|
252
|
-
sleepMs(10 * (attempt + 1)); // 瞬时竞争窗口,退避重试
|
|
253
|
-
}
|
|
254
|
-
}
|
|
255
|
-
if (lastErr) {
|
|
256
|
-
throw new Error(
|
|
257
|
-
"读取状态失败(" + (lastErr.code || lastErr.message) + "):" + file +
|
|
258
|
-
"。为避免丢掉门禁状态,本次操作已中止,请稍后重试。",
|
|
259
|
-
);
|
|
260
|
-
}
|
|
261
|
-
|
|
262
|
-
let parsed;
|
|
263
|
-
try {
|
|
264
|
-
parsed = JSON.parse(raw);
|
|
265
|
-
} catch (e) {
|
|
266
|
-
throw new Error(
|
|
267
|
-
"状态文件损坏,无法解析:" + file + "(" + e.message + ")。" +
|
|
268
|
-
"为避免丢掉门禁状态,本次操作已中止;如确认可丢弃该会话状态,可删除该文件后重试。",
|
|
269
|
-
);
|
|
270
|
-
}
|
|
271
|
-
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return defaultState();
|
|
272
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null, ...defaultState(), ...migrate(parsed) };
|
|
273
|
-
}
|
|
274
|
-
|
|
275
|
-
export function saveState(sid, state) {
|
|
276
|
-
// 落盘脱敏:`state.card` 可能携带密钥片段(verify.cmd/token/password),
|
|
277
|
-
// 不能明文落盘。sanitizeFields 只脱敏 value,key 名保留。
|
|
278
|
-
const safeState = sanitizeFields(state ?? defaultState());
|
|
279
|
-
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
280
|
-
fs.mkdirSync(dir, { recursive: true });
|
|
281
|
-
const tmp = path.join(dir, "state.json.tmp");
|
|
282
|
-
const target = path.join(dir, "state.json");
|
|
283
|
-
fs.writeFileSync(tmp, JSON.stringify(safeState, null, 2), "utf8");
|
|
284
|
-
fs.renameSync(tmp, target);
|
|
285
|
-
return target;
|
|
286
|
-
}
|
|
287
|
-
|
|
288
|
-
// 跨进程排他锁。
|
|
289
|
-
// 问题背景:flow_submit_requirement 是「读状态 → 算 pending → 写状态」的读-改-写,
|
|
290
|
-
// 多个 MCP server 进程共享同一个 CARLOS_FLOW_HOME 时会互相丢更新:
|
|
291
|
-
// 进程A 写(占位卡, pending=[三项]) 与 进程B 写(普通空卡, pending=[])
|
|
292
|
-
// 若两者交错,后写入者可能用**过期的 prevState** 算出 pending=[],
|
|
293
|
-
// 而它写入的卡片字段仍为空 —— 闸门就被绕过了(红队实测 40 轮复现 4 次)。
|
|
294
|
-
// 这里用 mkdir 的原子性做锁(open(..., "wx") 同理),把读-改-写包成临界区。
|
|
295
|
-
const sleepMs = (ms) => {
|
|
296
|
-
try {
|
|
297
|
-
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
|
|
298
|
-
} catch {
|
|
299
|
-
/* SharedArrayBuffer 不可用时退化为自旋 */
|
|
300
|
-
}
|
|
301
|
-
};
|
|
302
|
-
|
|
303
|
-
export function withStateLock(sid, fn, opts = {}) {
|
|
304
|
-
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
305
|
-
const lockFile = path.join(dir, ".state.lock");
|
|
306
|
-
const timeoutMs = Number(opts.timeoutMs) || 5000;
|
|
307
|
-
const staleMs = Number(opts.staleMs) || 30000;
|
|
308
|
-
const deadline = Date.now() + timeoutMs;
|
|
309
|
-
let acquired = false;
|
|
310
|
-
|
|
311
|
-
for (;;) {
|
|
312
|
-
try {
|
|
313
|
-
fs.mkdirSync(dir, { recursive: true });
|
|
314
|
-
// wx = O_CREAT|O_EXCL,文件已存在则抛 EEXIST —— 原子排他
|
|
315
|
-
const fd = fs.openSync(lockFile, "wx");
|
|
316
|
-
fs.closeSync(fd);
|
|
317
|
-
acquired = true;
|
|
318
|
-
break;
|
|
319
|
-
} catch (e) {
|
|
320
|
-
if (e.code !== "EEXIST") throw e;
|
|
321
|
-
// 陈旧锁(持有者已崩溃)→ 回收
|
|
322
|
-
try {
|
|
323
|
-
const st = fs.statSync(lockFile);
|
|
324
|
-
if (Date.now() - st.mtimeMs > staleMs) {
|
|
325
|
-
fs.unlinkSync(lockFile);
|
|
326
|
-
continue;
|
|
327
|
-
}
|
|
328
|
-
} catch {
|
|
329
|
-
continue; // 锁刚好被释放,重试
|
|
330
|
-
}
|
|
331
|
-
if (Date.now() > deadline) {
|
|
332
|
-
// 拿不到锁:fail-closed —— 宁可报错也不要在无锁下写状态
|
|
333
|
-
throw new Error(`获取状态锁超时(session=${sanitizeId(sid)}),请稍后重试`);
|
|
334
|
-
}
|
|
335
|
-
sleepMs(15);
|
|
336
|
-
}
|
|
337
|
-
}
|
|
338
|
-
|
|
339
|
-
try {
|
|
340
|
-
return fn();
|
|
341
|
-
} finally {
|
|
342
|
-
if (acquired) {
|
|
343
|
-
try { fs.unlinkSync(lockFile); } catch { /* 已回收 */ }
|
|
344
|
-
}
|
|
345
|
-
}
|
|
346
|
-
}
|
|
347
|
-
|
|
348
|
-
// 追加审计行;永不抛错,失败仅写 stderr;返回记录对象
|
|
349
|
-
// 读取审计文件最后一条记录的 hash(多进程安全:每次从磁盘尾部取,不依赖进程内变量)
|
|
350
|
-
// 旧格式记录没有 hash 字段 → 视为链起点(prev = 全 0)
|
|
351
|
-
function lastHashOf(file) {
|
|
352
|
-
const ZERO = ZERO_HASH;
|
|
353
|
-
try {
|
|
354
|
-
const stat = fs.statSync(file);
|
|
355
|
-
if (!stat || stat.size === 0) return ZERO;
|
|
356
|
-
const len = Math.min(stat.size, 8192);
|
|
357
|
-
const buf = Buffer.alloc(len);
|
|
358
|
-
const fd = fs.openSync(file, "r");
|
|
359
|
-
try {
|
|
360
|
-
fs.readSync(fd, buf, 0, len, stat.size - len);
|
|
361
|
-
} finally {
|
|
362
|
-
fs.closeSync(fd);
|
|
363
|
-
}
|
|
364
|
-
const lines = buf.toString("utf8").split("\n").filter((l) => l.trim());
|
|
365
|
-
for (let i = lines.length - 1; i >= 0; i--) {
|
|
366
|
-
try {
|
|
367
|
-
const r = JSON.parse(lines[i]);
|
|
368
|
-
if (r && typeof r.hash === "string" && r.hash.length === 64) return r.hash;
|
|
369
|
-
} catch {
|
|
370
|
-
/* 坏行跳过 */
|
|
371
|
-
}
|
|
372
|
-
}
|
|
373
|
-
return ZERO;
|
|
374
|
-
} catch {
|
|
375
|
-
return ZERO;
|
|
376
|
-
}
|
|
377
|
-
}
|
|
378
|
-
|
|
379
|
-
// 审计文件按天分片(`${localDate()}.jsonl`)。
|
|
380
|
-
//
|
|
381
|
-
// 审计链是「分片链表」:前一天的最后一条记录的 hash 应当传给后一天的第一条
|
|
382
|
-
// 的 prevHash。**旧代码 `audit()` 只取当天文件的 tail**(当天文件不存在时退化成
|
|
383
|
-
// 全 0),于是链子每天都在午夜断开——攻击者篡改**任意历史天**的记录,今天
|
|
384
|
-
// 的 `verifyAuditChain()` 查不出来。
|
|
385
|
-
//
|
|
386
|
-
// 新增三个辅助:
|
|
387
|
-
// · auditDayFiles() → 按日期升序排列的审计文件清单
|
|
388
|
-
// · lastHashOfDay(date)→ 某天文件最后一条记录的 hash(不存在那一天退化为 ZERO)
|
|
389
|
-
// · nextPrevHash(date) → 取「当天 tail」,当天没有则往前找最近一天的 tail
|
|
390
|
-
//
|
|
391
|
-
// `audit()` 用 nextPrevHash 把每天的 tail 串成完整链,
|
|
392
|
-
// `verifyAuditChain()` 用同一套规则逐天串联验证。
|
|
393
|
-
function auditDayFiles() {
|
|
394
|
-
try {
|
|
395
|
-
return fs.readdirSync(AUDIT_DIR).filter((f) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(f)).sort();
|
|
396
|
-
} catch {
|
|
397
|
-
return [];
|
|
398
|
-
}
|
|
399
|
-
}
|
|
400
|
-
|
|
401
|
-
function lastHashOfDay(date) {
|
|
402
|
-
return lastHashOf(path.join(AUDIT_DIR, `${date}.jsonl`));
|
|
403
|
-
}
|
|
404
|
-
|
|
405
|
-
// 取「当天 tail」,当天没有就往前找最近一天的 tail(修跨天断链)
|
|
406
|
-
function nextPrevHash(date) {
|
|
407
|
-
const file = path.join(AUDIT_DIR, `${date}.jsonl`);
|
|
408
|
-
const prev = lastHashOf(file);
|
|
409
|
-
if (prev !== "0".repeat(64)) return prev; // 当天有链,正常运行
|
|
410
|
-
// 当天还没有记录:**从 date 前一天起**按日期降序找最近已有 tail,绝不看 future。
|
|
411
|
-
const today = localDate();
|
|
412
|
-
const sorted = auditDayFiles().sort().filter((f) => f.slice(0, 10) < today);
|
|
413
|
-
for (let i = sorted.length - 1; i >= 0; i--) {
|
|
414
|
-
if (sorted[i].slice(0, 10) >= date) continue; // 只能找 date 之前的
|
|
415
|
-
const h = lastHashOf(path.join(AUDIT_DIR, sorted[i]));
|
|
416
|
-
if (h !== "0".repeat(64)) return h;
|
|
417
|
-
}
|
|
418
|
-
return "0".repeat(64);
|
|
419
|
-
}
|
|
420
|
-
// 哈希载荷:除链字段外的全部字段,保持写入/校验口径完全一致
|
|
421
|
-
function auditPayload(rec) {
|
|
422
|
-
const SKIP = new Set(["ts", "type", "sessionID", "prevHash", "hash"]);
|
|
423
|
-
const out = {};
|
|
424
|
-
for (const k of Object.keys(rec)) {
|
|
425
|
-
if (!SKIP.has(k)) out[k] = rec[k];
|
|
426
|
-
}
|
|
427
|
-
return JSON.stringify(out);
|
|
428
|
-
}
|
|
429
|
-
|
|
430
|
-
// 敏感信息脱敏
|
|
431
|
-
//
|
|
432
|
-
// 用户卡片里可能包含密钥/密码(`verify.cmd` 里的 `sk_live_xxx`、`token`、
|
|
433
|
-
// `password`),审计记录也接受任意 `fields`——如果原样落盘,**门禁本身成了泄露源**。
|
|
434
|
-
//
|
|
435
|
-
// 规则:
|
|
436
|
-
// · key 命中 `secret/key/password/pwd/token/credential/auth` 之一(不区分大小写)
|
|
437
|
-
// · 或 string value 里含有 `sk_|secret=|password=|token=|api_key=|sk_live|sk_test`
|
|
438
|
-
// → 记为敏感 value,脱敏:长度 ≤ 8 → `[脱敏]`,否则头尾各保留 4 个字符中间 ***
|
|
439
|
-
//
|
|
440
|
-
// 任何异常都不可抛(`audit` 必须永不抛错),脱敏失败则原地返回原值。
|
|
441
|
-
function isSensitiveKey(k) {
|
|
442
|
-
try {
|
|
443
|
-
return typeof k === "string" && /[Ss]ecret|[Kk]ey|[Pp]assword|[Pp]wd|[Tt]oken|[Cc]redential|[Aa]uth/.test(k);
|
|
444
|
-
} catch {
|
|
445
|
-
return false;
|
|
446
|
-
}
|
|
447
|
-
}
|
|
448
|
-
const SENSITIVE_VALUES_RE = /sk_|secret=|password=|token=|api_key=|sk_live|sk_test|secret:/i;
|
|
449
|
-
function isSensitiveValue(v) {
|
|
450
|
-
try {
|
|
451
|
-
return typeof v === "string" && v.length > 0 && SENSITIVE_VALUES_RE.test(v);
|
|
452
|
-
} catch {
|
|
453
|
-
return false;
|
|
454
|
-
}
|
|
455
|
-
}
|
|
456
|
-
function maskValue(v) {
|
|
457
|
-
try {
|
|
458
|
-
if (typeof v === "string" && v.length > 0) {
|
|
459
|
-
if (v.length <= 8) return "[脱敏]";
|
|
460
|
-
return v.slice(0, 4) + "***" + v.slice(-4);
|
|
461
|
-
}
|
|
462
|
-
return v;
|
|
463
|
-
} catch {
|
|
464
|
-
return v;
|
|
465
|
-
}
|
|
466
|
-
}
|
|
467
|
-
function sanitizeValue(v) {
|
|
468
|
-
try {
|
|
469
|
-
if (Array.isArray(v)) return v.map(sanitizeValue);
|
|
470
|
-
if (v && typeof v === "object") {
|
|
471
|
-
const out = {};
|
|
472
|
-
for (const k of Object.keys(v)) {
|
|
473
|
-
const val = v[k];
|
|
474
|
-
out[k] = isSensitiveKey(k) || isSensitiveValue(val) ? maskValue(val) : sanitizeValue(val);
|
|
475
|
-
}
|
|
476
|
-
return out;
|
|
477
|
-
}
|
|
478
|
-
return v;
|
|
479
|
-
} catch {
|
|
480
|
-
return v;
|
|
481
|
-
}
|
|
482
|
-
}
|
|
483
|
-
export function sanitizeFields(o) {
|
|
484
|
-
return sanitizeValue(o ?? {});
|
|
485
|
-
}
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
// ---- 审计链哈希模式 ----
|
|
489
|
-
//
|
|
490
|
-
// 裸 SHA-256 哈希链能防的是「**意外**损坏」(截断、位翻转、误删),
|
|
491
|
-
// **防不了有意篡改**:攻击者能读文件,就能重算整条链。
|
|
492
|
-
//
|
|
493
|
-
// 因此提供两种模式:
|
|
494
|
-
// · hmac —— 设置了 CARLOS_FLOW_AUDIT_KEY 时使用带密钥的 HMAC-SHA256。
|
|
495
|
-
// 攻击者没有密钥 → 重算不出正确 hash → 篡改必被发现。
|
|
496
|
-
// · plain —— 未设置密钥时的降级模式(裸 SHA-256),**在 verify 结果里
|
|
497
|
-
// 显式标注 mode**,让调用方知道自己拿到的是哪种保证。
|
|
498
|
-
//
|
|
499
|
-
// 不做「默认启用 HMAC」:没有密钥就签不了名,用户第一次用就会报错。
|
|
500
|
-
// 也不做「假装 HMAC」:plain 模式必须诚实地说自己只是弱保证。
|
|
501
|
-
const AUDIT_KEY = (() => {
|
|
502
|
-
const k = process.env.CARLOS_FLOW_AUDIT_KEY;
|
|
503
|
-
return typeof k === "string" && k.length >= 16 ? k : null;
|
|
504
|
-
})();
|
|
505
|
-
|
|
506
|
-
export function auditHashMode() {
|
|
507
|
-
return AUDIT_KEY ? "hmac" : "plain";
|
|
508
|
-
}
|
|
509
|
-
|
|
510
|
-
// 计算一条记录的 hash(写入与校验必须用同一套函数,否则永远对不上)
|
|
511
|
-
function computeAuditHash(rec, prev) {
|
|
512
|
-
const payload = rec.ts + rec.type + rec.sessionID + auditPayload(rec) + prev;
|
|
513
|
-
if (AUDIT_KEY) {
|
|
514
|
-
return createHmac("sha256", AUDIT_KEY).update(payload).digest("hex");
|
|
515
|
-
}
|
|
516
|
-
return createHash("sha256").update(payload).digest("hex");
|
|
517
|
-
}
|
|
518
|
-
|
|
519
|
-
// 追加审计行;永不抛错,失败仅写 stderr;返回记录对象
|
|
520
|
-
export function audit(type, sid, fields = {}) {
|
|
521
|
-
// 落盘脱敏:用户卡片/审计字段里的密钥片段(verify.cmd 等)不能明文入盘。
|
|
522
|
-
const sanitized = sanitizeFields(fields);
|
|
523
|
-
const rec = {
|
|
524
|
-
ts: new Date().toISOString(),
|
|
525
|
-
type,
|
|
526
|
-
sessionID: sanitizeId(sid),
|
|
527
|
-
...sanitized,
|
|
528
|
-
};
|
|
529
|
-
try {
|
|
530
|
-
fs.mkdirSync(AUDIT_DIR, { recursive: true });
|
|
531
|
-
const file = path.join(AUDIT_DIR, `${localDate()}.jsonl`);
|
|
532
|
-
// 前驱 hash 取自当天文件 tail;当天没有记录时退成分片链上一天的 tail
|
|
533
|
-
//(nextPrevHash),这样审计链在午夜也不断开。
|
|
534
|
-
const prev = nextPrevHash(localDate());
|
|
535
|
-
rec.prevHash = prev;
|
|
536
|
-
rec.hash = computeAuditHash(rec, prev);
|
|
537
|
-
// 单次 appendFileSync:O_APPEND 语义,多进程并发写不会互相截断
|
|
538
|
-
fs.appendFileSync(file, JSON.stringify(rec) + "\n", "utf8");
|
|
539
|
-
} catch (e) {
|
|
540
|
-
try {
|
|
541
|
-
process.stderr.write(`[flow-audit] 写入失败: ${e && e.message ? e.message : e}\n`);
|
|
542
|
-
} catch {}
|
|
543
|
-
}
|
|
544
|
-
return rec;
|
|
545
|
-
}
|
|
546
|
-
|
|
547
|
-
// 校验审计链完整性(可选:需完整文件,不能只看尾部)。
|
|
548
|
-
//
|
|
549
|
-
// 审计文件按天分片(`localDate().jsonl`),审计链是「分片链表」:
|
|
550
|
-
// 前一天最后一条记录的 hash 是后一天第一条记录的 prevHash(nextPrevHash)。
|
|
551
|
-
// 所以默认 `verifyAuditChain()` **逐天串联所有记录** 验证整条链——
|
|
552
|
-
// 攻击者篡改任意一天的任意记录,整链检测都会 break(配合 CARLOS_FLOW_AUDIT_KEY
|
|
553
|
-
// 为 HMAC 时做得到;plain 模式可在推荐结果里看到 mode 降级声明)。
|
|
554
|
-
//
|
|
555
|
-
// `opts.date` 给定的一天 → 只验证那一天(验证起点是前一天 tail,跨天)。
|
|
556
|
-
// `opts.fullChain` 默认 true → 验证全部天的完整链。
|
|
557
|
-
export function verifyAuditChain(opts = {}) {
|
|
558
|
-
const rawDate = typeof opts.date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(opts.date) ? opts.date : localDate();
|
|
559
|
-
// ⚠️ 必须用 rawDate(而不是 localDate())—— 否则 opts.date 完全失效:
|
|
560
|
-
// 传 date='2020-01-01' 读的仍是**今天**的文件,调用方以为在查历史、
|
|
561
|
-
// 实际拿到今天的数据(错而不报,最难发现)。
|
|
562
|
-
const fullChain = typeof opts.fullChain === "boolean" ? opts.fullChain : true;
|
|
563
|
-
if (fullChain && !opts.date) {
|
|
564
|
-
// 全链验证:逐天(按文件名升序 == 升时)串联,每天的 tail 是下一天的 prevHash。
|
|
565
|
-
//
|
|
566
|
-
// 跨天重启容忍(2026-11-14):
|
|
567
|
-
// 写入侧 nextPrevHash() 取「当天文件最后一条**带 hash** 的记录」作为前驱;
|
|
568
|
-
// 若当天先前的记录都是 v2.5 升级上来的 legacy 记录(无 hash),就取不到 tail,
|
|
569
|
-
// 于是这条链首记录的 prevHash 只能是全 0。
|
|
570
|
-
// 这不是篡改,是**合法的链首**。旧校验器一律要求 prevHash === 运行中的 prev,
|
|
571
|
-
// 于是每天的第一条带 hash 记录都被判 broken —— 实测 4 处误报全部是这个形态。
|
|
572
|
-
// 误报比漏报更伤信任(同 legacy 那条注释的口径)。
|
|
573
|
-
//
|
|
574
|
-
// 规则:一天内**第一条带 hash 的记录**若 prevHash 为全 0,
|
|
575
|
-
// 按链首处理 —— 用它自己的 prevHash(全 0)重算 hash,吻合即放行;
|
|
576
|
-
// 从它开始照常串联。计数为 dayRestart,与 broken 分开报,不静默吞掉。
|
|
577
|
-
const files = auditDayFiles();
|
|
578
|
-
const byDay = [];
|
|
579
|
-
let total = 0, broken = 0, legacy = 0, restart = 0;
|
|
580
|
-
const brokenAt = [];
|
|
581
|
-
let prev = ZERO_HASH; // 链起点
|
|
582
|
-
for (const f of files) {
|
|
583
|
-
let raw = "";
|
|
584
|
-
try {
|
|
585
|
-
raw = fs.readFileSync(path.join(AUDIT_DIR, f), "utf8");
|
|
586
|
-
} catch {
|
|
587
|
-
continue;
|
|
588
|
-
}
|
|
589
|
-
let dayBroken = 0, dayLegacy = 0, dayRestart = 0;
|
|
590
|
-
let hashedSeen = 0;
|
|
591
|
-
for (const line of raw.split("\n")) {
|
|
592
|
-
const t = line.trim();
|
|
593
|
-
if (!t) continue;
|
|
594
|
-
let r;
|
|
595
|
-
try {
|
|
596
|
-
r = JSON.parse(t);
|
|
597
|
-
} catch {
|
|
598
|
-
continue;
|
|
599
|
-
}
|
|
600
|
-
total++;
|
|
601
|
-
if (typeof r.hash !== "string") {
|
|
602
|
-
// 旧格式记录(无 hash)→ 计入 legacy 计数,但**不重置链起点**
|
|
603
|
-
legacy++;
|
|
604
|
-
dayLegacy++;
|
|
605
|
-
continue;
|
|
606
|
-
}
|
|
607
|
-
hashedSeen++;
|
|
608
|
-
// 一天内的首条带 hash 记录且 prevHash 为全 0 → 合法链首(见上)。
|
|
609
|
-
const isDayStart = hashedSeen === 1 && r.prevHash === ZERO_HASH;
|
|
610
|
-
const base = isDayStart ? ZERO_HASH : prev;
|
|
611
|
-
const expect = computeAuditHash(r, base);
|
|
612
|
-
if (isDayStart) {
|
|
613
|
-
// 只有当它自己的 hash 确实是用全 0 前驱算出来的才算合法链首;
|
|
614
|
-
// 否则仍按 broken 处理(防「把任意记录伪装成链首」)。
|
|
615
|
-
if (expect === r.hash) {
|
|
616
|
-
restart++;
|
|
617
|
-
dayRestart++;
|
|
618
|
-
prev = r.hash;
|
|
619
|
-
continue;
|
|
620
|
-
}
|
|
621
|
-
}
|
|
622
|
-
if (expect !== r.hash || r.prevHash !== base) {
|
|
623
|
-
broken++;
|
|
624
|
-
dayBroken++;
|
|
625
|
-
if (brokenAt.length < 10) brokenAt.push({ date: f.slice(0, 10), ts: r.ts, type: r.type, kind: r.kind });
|
|
626
|
-
}
|
|
627
|
-
prev = r.hash;
|
|
628
|
-
}
|
|
629
|
-
byDay.push({ date: f.slice(0, 10), dayBroken, dayLegacy, dayRestart, tailHash: prev });
|
|
630
|
-
}
|
|
631
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
632
|
-
ok: broken === 0, total, broken, legacy, restart, brokenAt, byDay, mode: auditHashMode(),
|
|
633
|
-
note: "全链验证:逐天串联,每天的 tail 是下一天的前驱。dayRestart 为「当天首条带 hash 记录以全 0 前驱合法起链」的处数,不是篡改。",
|
|
634
|
-
};
|
|
635
|
-
}
|
|
636
|
-
|
|
637
|
-
// 单日验证:按 date 读一天文件,链起点用前一天 tail(跨天联动)或全 0(新链第一天)。
|
|
638
|
-
const file = path.join(AUDIT_DIR, `${rawDate}.jsonl`);
|
|
639
|
-
let raw = "";
|
|
640
|
-
try {
|
|
641
|
-
raw = fs.readFileSync(file, "utf8");
|
|
642
|
-
} catch {
|
|
643
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: true, total: 0, broken: 0, legacy: 0, brokenAt: [], file, mode: auditHashMode() };
|
|
644
|
-
}
|
|
645
|
-
// 单日的链起点:前一个 tail hash(跨天)或全 0(新链第一天)。
|
|
646
|
-
const files = auditDayFiles();
|
|
647
|
-
let prev = "0".repeat(64);
|
|
648
|
-
for (const f of files) {
|
|
649
|
-
if (f === `${rawDate}.jsonl`) break;
|
|
650
|
-
prev = lastHashOf(path.join(AUDIT_DIR, f));
|
|
651
|
-
}
|
|
652
|
-
let total = 0, broken = 0, legacy = 0;
|
|
653
|
-
const brokenAt = [];
|
|
654
|
-
for (const line of raw.split("\n")) {
|
|
655
|
-
const t = line.trim();
|
|
656
|
-
if (!t) continue;
|
|
657
|
-
let r;
|
|
658
|
-
try {
|
|
659
|
-
r = JSON.parse(t);
|
|
660
|
-
} catch {
|
|
661
|
-
continue;
|
|
662
|
-
}
|
|
663
|
-
total++;
|
|
664
|
-
if (typeof r.hash !== "string") {
|
|
665
|
-
// 旧格式记录(无 hash)→ 计入 legacy 计数,但**不重置链起点**。
|
|
666
|
-
//
|
|
667
|
-
// 早先这里写的是 prev = "0".repeat(64),于是**一条**旧记录就会让
|
|
668
|
-
// 它之后所有记录的 prevHash 全部对不上 → 全判 broken。
|
|
669
|
-
// 后果:v2.5 升级上来的用户,审计链校验会长期报红,
|
|
670
|
-
// 而 README 把「可验证审计链」列为核心能力 —— 用户会以为自己的
|
|
671
|
-
// 审计记录被篡改了。**漏报比误报可接受,误报更伤信任。**
|
|
672
|
-
legacy++;
|
|
673
|
-
continue;
|
|
674
|
-
}
|
|
675
|
-
const expect = computeAuditHash(r, prev);
|
|
676
|
-
if (expect !== r.hash || r.prevHash !== prev) {
|
|
677
|
-
broken++;
|
|
678
|
-
if (brokenAt.length < 10) brokenAt.push({ ts: r.ts, type: r.type, kind: r.kind });
|
|
679
|
-
}
|
|
680
|
-
prev = r.hash;
|
|
681
|
-
}
|
|
682
|
-
// mode 字段说明本次校验的**保证强度**:
|
|
683
|
-
// hmac → 带密钥(CARLOS_FLOW_AUDIT_KEY),能发现有意篡改
|
|
684
|
-
// plain → 裸 SHA-256,只能发现意外损坏(攻击者能重算整条链)
|
|
685
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: broken === 0, total, broken, legacy, brokenAt, file, mode: auditHashMode() };
|
|
686
|
-
}
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
export function readAudit(opts = {}) {
|
|
690
|
-
const { sessionId, type, limit } = opts;
|
|
691
|
-
const rawDate = typeof opts.date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(opts.date) ? opts.date : localDate();
|
|
692
|
-
try {
|
|
693
|
-
// ⚠️ 必须用 rawDate(而不是 localDate())—— 否则 opts.date 完全失效。
|
|
694
|
-
const file = path.join(AUDIT_DIR, `${rawDate}.jsonl`);
|
|
695
|
-
const raw = fs.readFileSync(file, "utf8");
|
|
696
|
-
const out = [];
|
|
697
|
-
for (const line of raw.split("\n")) {
|
|
698
|
-
const t = line.trim();
|
|
699
|
-
if (!t) continue;
|
|
700
|
-
let rec;
|
|
701
|
-
try {
|
|
702
|
-
rec = JSON.parse(t);
|
|
703
|
-
} catch {
|
|
704
|
-
continue; // 坏行跳过
|
|
705
|
-
}
|
|
706
|
-
if (sessionId != null && rec.sessionID !== sanitizeId(sessionId)) continue;
|
|
707
|
-
if (type != null && rec.type !== type) continue;
|
|
708
|
-
out.push(rec);
|
|
709
|
-
}
|
|
710
|
-
if (typeof limit === "number" && limit >= 0) return out.slice(-limit); // 取最近 N 条
|
|
711
|
-
return out;
|
|
712
|
-
} catch {
|
|
713
|
-
return [];
|
|
714
|
-
}
|
|
715
|
-
}
|
|
716
|
-
|
|
717
|
-
// 从用户消息源读取原文(quote 锚点数据源)。
|
|
718
|
-
// 三个来源按优先级合并:
|
|
719
|
-
// 1. $CARLOS_USER_MSGS —— 启动时注入的 JSON 数组(最直接)
|
|
720
|
-
// 2. RUNS_DIR/<sid>/user_msgs.jsonl —— 本会话写入的用户原话(Cindy 路径)
|
|
721
|
-
// 3. OpenCode SQLite —— 宿主是 OpenCode 时直接读它的会话库
|
|
722
|
-
// 任何异常 → 返回 null,绝不抛错。
|
|
723
|
-
export async function getUserMessages(sid, limit = 20) {
|
|
724
|
-
const out = [];
|
|
725
|
-
|
|
726
|
-
// 1. 环境变量注入
|
|
727
|
-
try {
|
|
728
|
-
const envMsgs = process.env.CARLOS_USER_MSGS;
|
|
729
|
-
if (envMsgs) {
|
|
730
|
-
const arr = JSON.parse(envMsgs);
|
|
731
|
-
if (Array.isArray(arr)) {
|
|
732
|
-
for (const m of arr) if (typeof m === "string" && m !== "") out.push(m);
|
|
733
|
-
}
|
|
734
|
-
}
|
|
735
|
-
} catch {}
|
|
736
|
-
|
|
737
|
-
// 2. 会话目录里的 user_msgs.jsonl
|
|
738
|
-
try {
|
|
739
|
-
const file = path.join(RUNS_DIR, sanitizeId(sid), "user_msgs.jsonl");
|
|
740
|
-
if (fs.existsSync(file)) {
|
|
741
|
-
const raw = fs.readFileSync(file, "utf8");
|
|
742
|
-
for (const line of raw.split("\n")) {
|
|
743
|
-
const t = line.trim();
|
|
744
|
-
if (!t) continue;
|
|
745
|
-
try {
|
|
746
|
-
const rec = JSON.parse(t);
|
|
747
|
-
if (rec && typeof rec.text === "string" && rec.text !== "") out.push(rec.text);
|
|
748
|
-
} catch {}
|
|
749
|
-
}
|
|
750
|
-
}
|
|
751
|
-
} catch {}
|
|
752
|
-
|
|
753
|
-
// 3. OpenCode 会话库(宿主是 OpenCode 时的权威来源)
|
|
754
|
-
const fromOpenCode = await getOpenCodeUserMessages(sid, limit);
|
|
755
|
-
if (fromOpenCode && fromOpenCode.length) out.push(...fromOpenCode);
|
|
756
|
-
|
|
757
|
-
if (!out.length) return null;
|
|
758
|
-
return out.slice(-limit);
|
|
759
|
-
}
|
|
760
|
-
|
|
761
|
-
// 从 OpenCode 的 SQLite 会话库读用户原话。
|
|
762
|
-
// 路径可用 OPENCODE_DB_PATH / OPENCODE_DB 覆盖,默认 ~/.local/share/opencode/opencode.db。
|
|
763
|
-
// 任何异常(node:sqlite 不可用 / 库不存在 / 表结构变化)→ 返回 null,绝不抛错。
|
|
764
|
-
export async function getOpenCodeUserMessages(sid, limit = 20) {
|
|
765
|
-
let db = null;
|
|
766
|
-
try {
|
|
767
|
-
const mod = await import("node:sqlite");
|
|
768
|
-
const DatabaseSync = mod && mod.DatabaseSync;
|
|
769
|
-
if (typeof DatabaseSync !== "function") return null;
|
|
770
|
-
const dbPath = resolveOpenCodeDb();
|
|
771
|
-
if (!dbPath) return null;
|
|
772
|
-
try {
|
|
773
|
-
db = new DatabaseSync(dbPath, { readOnly: true });
|
|
774
|
-
} catch {
|
|
775
|
-
db = new DatabaseSync(dbPath, { readonly: true }); // 选项名兜底
|
|
776
|
-
}
|
|
777
|
-
let sql =
|
|
778
|
-
"SELECT p.data AS d FROM part p JOIN message m ON p.message_id=m.id" +
|
|
779
|
-
" WHERE json_extract(m.data,'$.role')='user' AND json_extract(p.data,'$.type')='text'";
|
|
780
|
-
const params = [];
|
|
781
|
-
if (sid) {
|
|
782
|
-
sql += " AND m.session_id=?";
|
|
783
|
-
params.push(sid);
|
|
784
|
-
}
|
|
785
|
-
sql += " ORDER BY p.time_created DESC LIMIT ?";
|
|
786
|
-
params.push(limit);
|
|
787
|
-
const rows = db.prepare(sql).all(...params);
|
|
788
|
-
const out = [];
|
|
789
|
-
for (const row of rows) {
|
|
790
|
-
let parsed;
|
|
791
|
-
try {
|
|
792
|
-
parsed = JSON.parse(row.d);
|
|
793
|
-
} catch {
|
|
794
|
-
continue;
|
|
795
|
-
}
|
|
796
|
-
const text = parsed && parsed.text;
|
|
797
|
-
if (typeof text === "string" && text !== "") out.push(text);
|
|
798
|
-
}
|
|
799
|
-
return out;
|
|
800
|
-
} catch {
|
|
801
|
-
return null;
|
|
802
|
-
} finally {
|
|
803
|
-
if (db) {
|
|
804
|
-
try {
|
|
805
|
-
db.close();
|
|
806
|
-
} catch {}
|
|
807
|
-
}
|
|
808
|
-
}
|
|
809
|
-
}
|
|
810
|
-
|
|
811
|
-
// 写入用户消息到会话目录(供 quote 锚点校验使用)
|
|
812
|
-
export function writeUserMessage(sid, text) {
|
|
813
|
-
try {
|
|
814
|
-
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
815
|
-
fs.mkdirSync(dir, { recursive: true });
|
|
816
|
-
const file = path.join(dir, "user_msgs.jsonl");
|
|
817
|
-
const rec = JSON.stringify({ ts: new Date().toISOString(), text }) + "\n";
|
|
818
|
-
fs.appendFileSync(file, rec, "utf8");
|
|
819
|
-
return true;
|
|
820
|
-
} catch {
|
|
821
|
-
return false;
|
|
822
|
-
}
|
|
823
|
-
}
|
|
824
|
-
|
|
825
|
-
export function pathExists(cwd, p) {
|
|
826
|
-
const abs = path.isAbsolute(p) ? p : path.join(cwd || process.cwd(), p);
|
|
827
|
-
return fs.existsSync(abs);
|
|
828
|
-
}
|
|
829
|
-
|
|
830
|
-
export function gitHead(cwd) {
|
|
831
|
-
try {
|
|
832
|
-
const r = spawnSync("git", ["rev-parse", "HEAD"], {
|
|
833
|
-
cwd: cwd || process.cwd(),
|
|
834
|
-
encoding: "utf8",
|
|
835
|
-
shell: false,
|
|
836
|
-
});
|
|
837
|
-
return r.status === 0 ? String(r.stdout || "").trim() : "";
|
|
838
|
-
} catch {
|
|
839
|
-
return "";
|
|
840
|
-
}
|
|
841
|
-
}
|
|
842
|
-
|
|
843
|
-
// card_ts 距今超过 ttlSec → true;无卡(card_ts 缺失/0)不视为过期
|
|
844
|
-
export function isStale(state, ttlSec = 14400) {
|
|
845
|
-
const ts = state ? Number(state.card_ts) : 0;
|
|
846
|
-
if (!ts) return false;
|
|
847
|
-
return Date.now() - ts > ttlSec * 1000;
|
|
848
|
-
}
|
|
849
|
-
|
|
850
|
-
// Phase 1-1: 检查 bypass 是否启用
|
|
851
|
-
export function isBypassed(state) {
|
|
852
|
-
if (!state || state.bypass !== true) return false;
|
|
853
|
-
// 免检必须显式开启(bypass_ts 有值)且发生在当前卡片之后,
|
|
854
|
-
// 否则旧卡片的免检状态会错误地作用于新卡片
|
|
855
|
-
if (!state.bypass_ts) return false;
|
|
856
|
-
if (state.card_ts && state.bypass_ts < state.card_ts) return false;
|
|
857
|
-
return true;
|
|
858
|
-
}
|
|
859
|
-
|
|
860
|
-
// ---------------------------------------------------------------------------
|
|
861
|
-
// workspaceFingerprint —— 工作区代码状态指纹
|
|
862
|
-
//
|
|
863
|
-
// 为什么需要(A1):
|
|
864
|
-
// 原来的 PASS 闸门只看 last_verify 的三个字段(存在 / ok===true / cmd 与卡片一致),
|
|
865
|
-
// **不绑定代码状态**。于是存在这条绕过路径:
|
|
866
|
-
// 1. flow_run_verify 跑通 → last_verify = {ok:true, cmd:"npm test"}
|
|
867
|
-
// 2. executor 继续改代码(甚至改坏)
|
|
868
|
-
// 3. flow_verdict(PASS) → 三个条件全满足 → 放行
|
|
869
|
-
// 指纹把「验证通过」绑定到**一次可复现的运行**:验证之后再动过代码,指纹就变了。
|
|
870
|
-
//
|
|
871
|
-
// 指纹构成:HEAD 提交 + `git diff HEAD` 的全文 + 全部未跟踪文件(路径 + 内容)。
|
|
872
|
-
// · 未跟踪文件必须计入:新建文件是最常见的越界/破坏手段。
|
|
873
|
-
// · `.carlos-flow/` 必须排除:跑一次检查会创建状态目录,计入则立即自我失效。
|
|
874
|
-
//
|
|
875
|
-
// 非 git 目录:显式返回 {ok:false, reason:"not_a_git_repo"},**不崩**。
|
|
876
|
-
// Carlos Flow 明确支持非 Git 项目,所以调用方要 fail-open(不阻断 PASS),
|
|
877
|
-
// 但要在 flow_status 里如实标注指纹不可用。
|
|
878
|
-
export function workspaceFingerprint(cwd) {
|
|
879
|
-
const dir = cwd || process.cwd();
|
|
880
|
-
const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: dir, encoding: "utf8" });
|
|
881
|
-
if (head.error || head.status !== 0) {
|
|
882
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: false, reason: "not_a_git_repo" };
|
|
883
|
-
}
|
|
884
|
-
const diff = spawnSync("git", ["diff", "HEAD", "--no-color"], { cwd: dir, encoding: "utf8" });
|
|
885
|
-
const untracked = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
|
|
886
|
-
cwd: dir,
|
|
887
|
-
encoding: "utf8",
|
|
888
|
-
});
|
|
889
|
-
|
|
890
|
-
const h = createHash("sha256");
|
|
891
|
-
h.update(String(diff.stdout || ""));
|
|
892
|
-
|
|
893
|
-
const files = String(untracked.stdout || "")
|
|
894
|
-
.split("\n")
|
|
895
|
-
.map((s) => s.trim())
|
|
896
|
-
.filter(Boolean)
|
|
897
|
-
.sort();
|
|
898
|
-
|
|
899
|
-
// 状态目录必须排除(R3):跑一次检查就会往里写审计/状态文件,
|
|
900
|
-
// 若计入指纹则「验证 → 落审计 → 记裁定」之间指纹必变 → 每次都误报 STALE。
|
|
901
|
-
//
|
|
902
|
-
// ⚠️ 不能只硬编码 ".carlos-flow/":状态目录由 CARLOS_FLOW_HOME 决定,
|
|
903
|
-
// 用户完全可以把它设在**项目内部**(如 <repo>/.flowhome),那就会自我失效。
|
|
904
|
-
// 所以这里按**解析后的绝对路径**排除真正的 FLOW_HOME,
|
|
905
|
-
// 同时保留 .carlos-flow/ 的字面排除以兼容默认布局。
|
|
906
|
-
const flowHomeAbs = path.resolve(FLOW_HOME);
|
|
907
|
-
for (const f of files) {
|
|
908
|
-
const abs = path.resolve(dir, f);
|
|
909
|
-
const inFlowHome = abs === flowHomeAbs || abs.startsWith(flowHomeAbs + path.sep);
|
|
910
|
-
if (inFlowHome) continue;
|
|
911
|
-
if (f.startsWith(".carlos-flow/") || f.startsWith(".carlos-flow\\")) continue;
|
|
912
|
-
h.update(`\u0000untracked-file:${f}\u0000`);
|
|
913
|
-
try {
|
|
914
|
-
const buf = fs.readFileSync(path.join(dir, f));
|
|
915
|
-
// 大文件只入路径 + 大小,不入内容(避免读上万文件/大文件)
|
|
916
|
-
if (buf.length > 1024 * 1024) {
|
|
917
|
-
h.update(`size:${buf.length}`);
|
|
918
|
-
} else {
|
|
919
|
-
h.update(buf);
|
|
920
|
-
}
|
|
921
|
-
} catch (e) {
|
|
922
|
-
h.update(`<<unreadable: ${e}>>`);
|
|
923
|
-
}
|
|
924
|
-
}
|
|
925
|
-
|
|
926
|
-
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
927
|
-
ok: true,
|
|
928
|
-
head: String(head.stdout || "").trim(),
|
|
929
|
-
diff_sha256: h.digest("hex"),
|
|
930
|
-
};
|
|
1
|
+
// state.js — Carlos 工作流:持久化 / 审计 / quote 数据源(Node ESM,零外部依赖)
|
|
2
|
+
import fs from "node:fs";
|
|
3
|
+
import path from "node:path";
|
|
4
|
+
import os from "node:os";
|
|
5
|
+
import { spawnSync } from "node:child_process";
|
|
6
|
+
import { createHash, createHmac } from "node:crypto";
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
// 展开路径里的 `~`(家目录)。
|
|
10
|
+
// 背景:README 让用户把 CARLOS_FLOW_HOME 写成 `~/.carlos-flow`,但此前**没有展开** ——
|
|
11
|
+
// path.normalize("~/.carlos-flow") 只是把斜杠改成反斜杠,路径仍是**字面量**,
|
|
12
|
+
// 于是状态/审计链被写到「当前工作目录下的一个名叫 ~ 的目录」里(Windows 实测
|
|
13
|
+
// FLOW_HOME = ~\.carlos-flow),位置诡异、极易丢失。
|
|
14
|
+
// 现在统一展开:`~` → homedir,`~/x` 与 `~\x` → homedir/x。
|
|
15
|
+
export function expandHome(p) {
|
|
16
|
+
if (typeof p !== "string" || p === "") return p;
|
|
17
|
+
if (p === "~") return os.homedir();
|
|
18
|
+
if (p.startsWith("~/") || p.startsWith("~\\")) {
|
|
19
|
+
return path.join(os.homedir(), p.slice(2));
|
|
20
|
+
}
|
|
21
|
+
return p;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
// 审计链的「链起点」占位值:64 个 0。
|
|
25
|
+
// 全零 prevHash = 「这条记录开启一条新链」,是合法的链首标记,
|
|
26
|
+
// 不是「校验失败」的证据 —— 早期版本写入器跨天不回连时就是这么写的。
|
|
27
|
+
const ZERO_HASH = "0".repeat(64);
|
|
28
|
+
|
|
29
|
+
export const FLOW_HOME = path.normalize(
|
|
30
|
+
expandHome(process.env.CARLOS_FLOW_HOME) || path.join(os.homedir(), ".carlos-flow")
|
|
31
|
+
);
|
|
32
|
+
export const AUDIT_DIR = path.join(FLOW_HOME, "gate-audit");
|
|
33
|
+
export const RUNS_DIR = path.join(FLOW_HOME, "gate-state", "runs");
|
|
34
|
+
|
|
35
|
+
// OpenCode 会话库路径:环境变量优先,回落到跨平台默认
|
|
36
|
+
// OPENCODE_DB_PATH / OPENCODE_DB 与插件侧同一套约定
|
|
37
|
+
// ~ 路径同样需要展开(Windows PowerShell 下 CARLOS_OPENCODE_DB=~/.opencode 会字面写入)
|
|
38
|
+
const OPENCODE_DB = path.normalize(
|
|
39
|
+
expandHome(process.env.OPENCODE_DB_PATH) ||
|
|
40
|
+
expandHome(process.env.OPENCODE_DB) ||
|
|
41
|
+
expandHome(process.env.CARLOS_OPENCODE_DB) ||
|
|
42
|
+
path.join(os.homedir(), ".local", "share", "opencode", "opencode.db")
|
|
43
|
+
);
|
|
44
|
+
|
|
45
|
+
// OpenCode 会话库的**候选路径**(按平台习惯不同,取第一个存在的)。
|
|
46
|
+
// 背景:原先只写死 XDG 路径 ~/.local/share/opencode/opencode.db —— 那是 Linux 的约定。
|
|
47
|
+
// macOS 上 OpenCode 实际落在 ~/Library/Application Support/opencode/,
|
|
48
|
+
// Windows 上落在 %APPDATA%\opencode\ —— 只探 XDG 路径的话,
|
|
49
|
+
// macOS/Windows 用户会**永远拿不到用户原话**,导致 quote 锚点校验直接失败、卡片无法提交。
|
|
50
|
+
// 环境变量优先(显式指定时不做任何猜测)。
|
|
51
|
+
const OPENCODE_DB_CANDIDATES = (() => {
|
|
52
|
+
const envPath = process.env.OPENCODE_DB_PATH || process.env.OPENCODE_DB || process.env.CARLOS_OPENCODE_DB;
|
|
53
|
+
if (envPath) return [path.normalize(envPath)];
|
|
54
|
+
const home = os.homedir();
|
|
55
|
+
const rel = ["opencode", "opencode.db"];
|
|
56
|
+
const candidates = [];
|
|
57
|
+
// XDG 约定(Linux,以及部分 macOS 配置)
|
|
58
|
+
candidates.push(path.join(home, ".local", "share", ...rel));
|
|
59
|
+
// macOS 原生
|
|
60
|
+
candidates.push(path.join(home, "Library", "Application Support", ...rel));
|
|
61
|
+
// Windows(APPDATA)
|
|
62
|
+
const appData = process.env.APPDATA;
|
|
63
|
+
if (appData) candidates.push(path.join(appData, ...rel));
|
|
64
|
+
// Windows(无 APPDATA 时的兜底)
|
|
65
|
+
candidates.push(path.join(home, "AppData", "Roaming", ...rel));
|
|
66
|
+
// 去重(保持顺序)
|
|
67
|
+
return [...new Set(candidates.map((p) => path.normalize(p)))];
|
|
68
|
+
})();
|
|
69
|
+
|
|
70
|
+
// 选出第一个真实存在的候选;都不存在则返回 null(不抛错,降级为“无历史消息”)。
|
|
71
|
+
function resolveOpenCodeDb() {
|
|
72
|
+
for (const p of OPENCODE_DB_CANDIDATES) {
|
|
73
|
+
try {
|
|
74
|
+
if (p && fs.existsSync(p)) return p;
|
|
75
|
+
} catch {
|
|
76
|
+
/* ignore */
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
return null;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
function localDate() {
|
|
83
|
+
const d = new Date();
|
|
84
|
+
const mm = String(d.getMonth() + 1).padStart(2, "0");
|
|
85
|
+
const dd = String(d.getDate()).padStart(2, "0");
|
|
86
|
+
return `${d.getFullYear()}-${mm}-${dd}`;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
export function sanitizeId(s) {
|
|
90
|
+
const v = String(s || "").replace(/[^A-Za-z0-9_.-]/g, "_");
|
|
91
|
+
if (v === "") return "unknown";
|
|
92
|
+
// 路径穿越防护:拒绝包含 .. 的 ID
|
|
93
|
+
if (v.includes("..")) {
|
|
94
|
+
throw new Error(`invalid session id (path traversal detected): ${s}`);
|
|
95
|
+
}
|
|
96
|
+
return v;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
// 当前状态文件结构版本号。
|
|
100
|
+
// 改动 defaultState() 的**字段结构**时,必须 +1 并在 migrate() 里加一条迁移。
|
|
101
|
+
export const CURRENT_SCHEMA_VERSION = 4;
|
|
102
|
+
|
|
103
|
+
/**
|
|
104
|
+
* 迁移旧版本的状态文件。
|
|
105
|
+
*
|
|
106
|
+
* 逐版本迁移,每一步都只处理「从 vN 到 vN+1」的差异,
|
|
107
|
+
* 保证任何历史版本都能一路迁到当前版本(不跳步)。
|
|
108
|
+
*
|
|
109
|
+
* v0 → v1:最早的版本没有 schemaVersion 字段(等于 v0)。
|
|
110
|
+
* · 补上 schemaVersion
|
|
111
|
+
* · dispatch_baseline 早期不存在 → 补空数组(无基线时裁定走全量判定,更保守)
|
|
112
|
+
*
|
|
113
|
+
* v1 → v2:新增 last_falsify(负对照记录)。
|
|
114
|
+
* · 旧状态没有这个字段 → 补 null(表示「还没做负对照」,裁定会拒绝 PASS)
|
|
115
|
+
*
|
|
116
|
+
* v2 → v3:新增 audit_axes / audit_axes_ts(双轴审查证据)。
|
|
117
|
+
* · 旧状态没有这两个字段 → 补默认结构(两轴均为 null = 尚未审查,裁定会拒绝 PASS)
|
|
118
|
+
* · audit_axes 存在但结构不全时也在此补齐,避免读到半初始化对象
|
|
119
|
+
*
|
|
120
|
+
* v3 → v4:新增 verdict_role(本条 PASS 是谁落的)。
|
|
121
|
+
* · 旧状态没有这个字段 → 补 null(仅影响可观测性,不影响门禁判定)
|
|
122
|
+
*/
|
|
123
|
+
export function migrate(parsed) {
|
|
124
|
+
if (!parsed || typeof parsed !== "object") return parsed;
|
|
125
|
+
let v = Number(parsed.schemaVersion);
|
|
126
|
+
if (!Number.isInteger(v) || v < 0) v = 0; // 无版本号 → 当作 v0
|
|
127
|
+
const out = { ...parsed };
|
|
128
|
+
|
|
129
|
+
if (v < 1) {
|
|
130
|
+
// v0 → v1
|
|
131
|
+
if (!Array.isArray(out.dispatch_baseline)) out.dispatch_baseline = [];
|
|
132
|
+
if (!Array.isArray(out.activation_pending)) out.activation_pending = [];
|
|
133
|
+
if (typeof out.activation_activated !== "boolean") out.activation_activated = false;
|
|
134
|
+
v = 1;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
if (v < 2) {
|
|
138
|
+
// v1 → v2
|
|
139
|
+
if (out.last_falsify === undefined) out.last_falsify = null;
|
|
140
|
+
v = 2;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
if (v < 3) {
|
|
144
|
+
// v2 → v3
|
|
145
|
+
if (!out.audit_axes || typeof out.audit_axes !== "object") {
|
|
146
|
+
out.audit_axes = { standards: null, spec: null };
|
|
147
|
+
} else {
|
|
148
|
+
out.audit_axes = {
|
|
149
|
+
standards: out.audit_axes.standards || null,
|
|
150
|
+
spec: out.audit_axes.spec || null,
|
|
151
|
+
};
|
|
152
|
+
}
|
|
153
|
+
if (typeof out.audit_axes_ts !== "number") out.audit_axes_ts = 0;
|
|
154
|
+
v = 3;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
if (v < 4) {
|
|
158
|
+
// v3 → v4
|
|
159
|
+
if (out.verdict_role === undefined) out.verdict_role = null;
|
|
160
|
+
v = 4;
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
out.schemaVersion = CURRENT_SCHEMA_VERSION;
|
|
164
|
+
return out;
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
export function defaultState() {
|
|
168
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
169
|
+
// 状态文件结构版本号。
|
|
170
|
+
// 为什么需要:早先靠 {...defaultState(), ...parsed} 做防御性合并,
|
|
171
|
+
// 但**没有版本号** —— 将来改字段名(如 bypass_ts → bypass_at)时,
|
|
172
|
+
// 老用户的 state.json 里那个旧字段会被当成「未知字段」静默丢弃,
|
|
173
|
+
// 表现为「免检没清零」「待补项丢失」这类**很难定位**的退化。
|
|
174
|
+
// 加了版本号 + migrate(),旧状态会被**显式迁移**而不是静默降级。
|
|
175
|
+
schemaVersion: CURRENT_SCHEMA_VERSION,
|
|
176
|
+
card: null,
|
|
177
|
+
card_ts: 0,
|
|
178
|
+
tier: "read_only",
|
|
179
|
+
task_id: null,
|
|
180
|
+
dispatch_count: 0,
|
|
181
|
+
claimed: false,
|
|
182
|
+
claimed_role: null,
|
|
183
|
+
write_files: 0,
|
|
184
|
+
last_user_ts: 0,
|
|
185
|
+
bypass: false,
|
|
186
|
+
bypass_ts: 0,
|
|
187
|
+
verdict: null,
|
|
188
|
+
completed_ok: false,
|
|
189
|
+
stale: false,
|
|
190
|
+
// 智能触发引擎激活占位卡时尚待补齐的字段。
|
|
191
|
+
// 非空时 flow_claim / flow_dispatch 会拒绝派发,防止空卡片被直接派发。
|
|
192
|
+
activation_pending: [],
|
|
193
|
+
// 该会话是否曾被智能触发引擎激活过(单调,只增不减)。
|
|
194
|
+
// 闸门状态由「卡片内容 + 此标记」幂等派生,不再依赖上一轮的 pending 传递,
|
|
195
|
+
// 这样跨进程并发写入也不会出现「卡片为空却 pending=[]」的矛盾组合。
|
|
196
|
+
activation_activated: false,
|
|
197
|
+
// 派发时记录的工作区改动基线(文件路径数组)。
|
|
198
|
+
// 用途:裁定前用「当前改动 - 基线」算出**本次执行引入的**改动,
|
|
199
|
+
// 再与卡片 scope 比对 —— 这样既能拦住越界,又不会把用户自己原有的
|
|
200
|
+
// 未提交改动误判为越界。没有基线时退化为全量判定(更保守,fail-closed)。
|
|
201
|
+
dispatch_baseline: [],
|
|
202
|
+
// 负对照记录(flow_falsify 写入)。
|
|
203
|
+
// 为什么需要:只看 exitCode===0 时,`verify.cmd` 可以是 `|| true` / `echo ok`
|
|
204
|
+
// 这类**空测试** —— 改动前后都退 0,门禁却以为「验证通过了」。
|
|
205
|
+
// 负对照要求:改动前必须失败、改动后必须通过,才证明这个测试真的在测本次改动。
|
|
206
|
+
// null = 还没做负对照(此时 flow_verdict 拒绝 PASS)。
|
|
207
|
+
last_falsify: null,
|
|
208
|
+
// 双轴审查证据(flow_audit_submit 写入)。
|
|
209
|
+
// 结构:{ standards: {verdict,findings,evidence,card_ts,ts} | null, spec: {...} | null }
|
|
210
|
+
//
|
|
211
|
+
// 为什么按轴绑定 card_ts,而不是只用一个全局时间戳:
|
|
212
|
+
// 两轴是**分两次**提交的。卡A提交 standards → 换新卡B → 只补 spec,
|
|
213
|
+
// 此时全局时间戳已被刷新到卡B之后,单看时间戳会放行,而 standards
|
|
214
|
+
// 仍是卡A的结论 —— 「两轴跨卡拼接」。绑定 card_ts 后,换卡即两轴全失效。
|
|
215
|
+
audit_axes: { standards: null, spec: null },
|
|
216
|
+
// 两轴最后提交时间(审计链留痕用;不参与冒充校验,校验看 card_ts)。
|
|
217
|
+
audit_axes_ts: 0,
|
|
218
|
+
// 本条裁定是谁落的("auditor" | "executor" | null)。
|
|
219
|
+
// 与 claimed_role 的区别:claimed_role 是「会话最近 claim 的角色」(可能已过期),
|
|
220
|
+
// verdict_role 是「实际写下这条裁定时传进来的 role」,直接回答「这条 PASS 是谁落的」。
|
|
221
|
+
// 审计流水里也有 role,但那是日志;这是状态层的持久记录,可用 flow_status 直接查。
|
|
222
|
+
verdict_role: null,
|
|
223
|
+
};
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
export function loadState(sid) {
|
|
227
|
+
const file = path.join(RUNS_DIR, sanitizeId(sid), "state.json");
|
|
228
|
+
|
|
229
|
+
// 读失败必须区分「真的没有」与「暂时读不到」。
|
|
230
|
+
//
|
|
231
|
+
// 背景(2026-11-13 实测):旧实现把**任何**读/解析失败都当成「状态不存在」,
|
|
232
|
+
// 返回 defaultState()。而 saveState 用的是 tmp+rename,
|
|
233
|
+
// 在 Windows 上 rename 与其他进程的 readFileSync 存在竞争窗口(EBUSY/EPERM),
|
|
234
|
+
// 读失败 → prev 退化成默认值 → activation_activated 丢成 false →
|
|
235
|
+
// 紧接着的写入把「占位卡的 pending=[三项]」覆盖成「普通卡的 pending=[]」
|
|
236
|
+
// → **激活闸门被绕过**。
|
|
237
|
+
// 这正是并发测试「零泄漏」偶发失败的根因(实测 370 轮里漏 1)。
|
|
238
|
+
//
|
|
239
|
+
// 现在:只有「文件不存在」才返回默认值;
|
|
240
|
+
// 瞬时错误先重试;仍失败则**报错**(fail-closed),
|
|
241
|
+
// 绝不静默把一个有闸门的状态当成无闸门的状态。
|
|
242
|
+
let raw = null;
|
|
243
|
+
let lastErr = null;
|
|
244
|
+
for (let attempt = 0; attempt < 5; attempt++) {
|
|
245
|
+
try {
|
|
246
|
+
raw = fs.readFileSync(file, "utf8");
|
|
247
|
+
lastErr = null;
|
|
248
|
+
break;
|
|
249
|
+
} catch (e) {
|
|
250
|
+
if (e.code === "ENOENT") return defaultState(); // 真的没有
|
|
251
|
+
lastErr = e;
|
|
252
|
+
sleepMs(10 * (attempt + 1)); // 瞬时竞争窗口,退避重试
|
|
253
|
+
}
|
|
254
|
+
}
|
|
255
|
+
if (lastErr) {
|
|
256
|
+
throw new Error(
|
|
257
|
+
"读取状态失败(" + (lastErr.code || lastErr.message) + "):" + file +
|
|
258
|
+
"。为避免丢掉门禁状态,本次操作已中止,请稍后重试。",
|
|
259
|
+
);
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
let parsed;
|
|
263
|
+
try {
|
|
264
|
+
parsed = JSON.parse(raw);
|
|
265
|
+
} catch (e) {
|
|
266
|
+
throw new Error(
|
|
267
|
+
"状态文件损坏,无法解析:" + file + "(" + e.message + ")。" +
|
|
268
|
+
"为避免丢掉门禁状态,本次操作已中止;如确认可丢弃该会话状态,可删除该文件后重试。",
|
|
269
|
+
);
|
|
270
|
+
}
|
|
271
|
+
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return defaultState();
|
|
272
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null, ...defaultState(), ...migrate(parsed) };
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
export function saveState(sid, state) {
|
|
276
|
+
// 落盘脱敏:`state.card` 可能携带密钥片段(verify.cmd/token/password),
|
|
277
|
+
// 不能明文落盘。sanitizeFields 只脱敏 value,key 名保留。
|
|
278
|
+
const safeState = sanitizeFields(state ?? defaultState());
|
|
279
|
+
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
280
|
+
fs.mkdirSync(dir, { recursive: true });
|
|
281
|
+
const tmp = path.join(dir, "state.json.tmp");
|
|
282
|
+
const target = path.join(dir, "state.json");
|
|
283
|
+
fs.writeFileSync(tmp, JSON.stringify(safeState, null, 2), "utf8");
|
|
284
|
+
fs.renameSync(tmp, target);
|
|
285
|
+
return target;
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
// 跨进程排他锁。
|
|
289
|
+
// 问题背景:flow_submit_requirement 是「读状态 → 算 pending → 写状态」的读-改-写,
|
|
290
|
+
// 多个 MCP server 进程共享同一个 CARLOS_FLOW_HOME 时会互相丢更新:
|
|
291
|
+
// 进程A 写(占位卡, pending=[三项]) 与 进程B 写(普通空卡, pending=[])
|
|
292
|
+
// 若两者交错,后写入者可能用**过期的 prevState** 算出 pending=[],
|
|
293
|
+
// 而它写入的卡片字段仍为空 —— 闸门就被绕过了(红队实测 40 轮复现 4 次)。
|
|
294
|
+
// 这里用 mkdir 的原子性做锁(open(..., "wx") 同理),把读-改-写包成临界区。
|
|
295
|
+
const sleepMs = (ms) => {
|
|
296
|
+
try {
|
|
297
|
+
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
|
|
298
|
+
} catch {
|
|
299
|
+
/* SharedArrayBuffer 不可用时退化为自旋 */
|
|
300
|
+
}
|
|
301
|
+
};
|
|
302
|
+
|
|
303
|
+
export function withStateLock(sid, fn, opts = {}) {
|
|
304
|
+
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
305
|
+
const lockFile = path.join(dir, ".state.lock");
|
|
306
|
+
const timeoutMs = Number(opts.timeoutMs) || 5000;
|
|
307
|
+
const staleMs = Number(opts.staleMs) || 30000;
|
|
308
|
+
const deadline = Date.now() + timeoutMs;
|
|
309
|
+
let acquired = false;
|
|
310
|
+
|
|
311
|
+
for (;;) {
|
|
312
|
+
try {
|
|
313
|
+
fs.mkdirSync(dir, { recursive: true });
|
|
314
|
+
// wx = O_CREAT|O_EXCL,文件已存在则抛 EEXIST —— 原子排他
|
|
315
|
+
const fd = fs.openSync(lockFile, "wx");
|
|
316
|
+
fs.closeSync(fd);
|
|
317
|
+
acquired = true;
|
|
318
|
+
break;
|
|
319
|
+
} catch (e) {
|
|
320
|
+
if (e.code !== "EEXIST") throw e;
|
|
321
|
+
// 陈旧锁(持有者已崩溃)→ 回收
|
|
322
|
+
try {
|
|
323
|
+
const st = fs.statSync(lockFile);
|
|
324
|
+
if (Date.now() - st.mtimeMs > staleMs) {
|
|
325
|
+
fs.unlinkSync(lockFile);
|
|
326
|
+
continue;
|
|
327
|
+
}
|
|
328
|
+
} catch {
|
|
329
|
+
continue; // 锁刚好被释放,重试
|
|
330
|
+
}
|
|
331
|
+
if (Date.now() > deadline) {
|
|
332
|
+
// 拿不到锁:fail-closed —— 宁可报错也不要在无锁下写状态
|
|
333
|
+
throw new Error(`获取状态锁超时(session=${sanitizeId(sid)}),请稍后重试`);
|
|
334
|
+
}
|
|
335
|
+
sleepMs(15);
|
|
336
|
+
}
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
try {
|
|
340
|
+
return fn();
|
|
341
|
+
} finally {
|
|
342
|
+
if (acquired) {
|
|
343
|
+
try { fs.unlinkSync(lockFile); } catch { /* 已回收 */ }
|
|
344
|
+
}
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
// 追加审计行;永不抛错,失败仅写 stderr;返回记录对象
|
|
349
|
+
// 读取审计文件最后一条记录的 hash(多进程安全:每次从磁盘尾部取,不依赖进程内变量)
|
|
350
|
+
// 旧格式记录没有 hash 字段 → 视为链起点(prev = 全 0)
|
|
351
|
+
function lastHashOf(file) {
|
|
352
|
+
const ZERO = ZERO_HASH;
|
|
353
|
+
try {
|
|
354
|
+
const stat = fs.statSync(file);
|
|
355
|
+
if (!stat || stat.size === 0) return ZERO;
|
|
356
|
+
const len = Math.min(stat.size, 8192);
|
|
357
|
+
const buf = Buffer.alloc(len);
|
|
358
|
+
const fd = fs.openSync(file, "r");
|
|
359
|
+
try {
|
|
360
|
+
fs.readSync(fd, buf, 0, len, stat.size - len);
|
|
361
|
+
} finally {
|
|
362
|
+
fs.closeSync(fd);
|
|
363
|
+
}
|
|
364
|
+
const lines = buf.toString("utf8").split("\n").filter((l) => l.trim());
|
|
365
|
+
for (let i = lines.length - 1; i >= 0; i--) {
|
|
366
|
+
try {
|
|
367
|
+
const r = JSON.parse(lines[i]);
|
|
368
|
+
if (r && typeof r.hash === "string" && r.hash.length === 64) return r.hash;
|
|
369
|
+
} catch {
|
|
370
|
+
/* 坏行跳过 */
|
|
371
|
+
}
|
|
372
|
+
}
|
|
373
|
+
return ZERO;
|
|
374
|
+
} catch {
|
|
375
|
+
return ZERO;
|
|
376
|
+
}
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
// 审计文件按天分片(`${localDate()}.jsonl`)。
|
|
380
|
+
//
|
|
381
|
+
// 审计链是「分片链表」:前一天的最后一条记录的 hash 应当传给后一天的第一条
|
|
382
|
+
// 的 prevHash。**旧代码 `audit()` 只取当天文件的 tail**(当天文件不存在时退化成
|
|
383
|
+
// 全 0),于是链子每天都在午夜断开——攻击者篡改**任意历史天**的记录,今天
|
|
384
|
+
// 的 `verifyAuditChain()` 查不出来。
|
|
385
|
+
//
|
|
386
|
+
// 新增三个辅助:
|
|
387
|
+
// · auditDayFiles() → 按日期升序排列的审计文件清单
|
|
388
|
+
// · lastHashOfDay(date)→ 某天文件最后一条记录的 hash(不存在那一天退化为 ZERO)
|
|
389
|
+
// · nextPrevHash(date) → 取「当天 tail」,当天没有则往前找最近一天的 tail
|
|
390
|
+
//
|
|
391
|
+
// `audit()` 用 nextPrevHash 把每天的 tail 串成完整链,
|
|
392
|
+
// `verifyAuditChain()` 用同一套规则逐天串联验证。
|
|
393
|
+
function auditDayFiles() {
|
|
394
|
+
try {
|
|
395
|
+
return fs.readdirSync(AUDIT_DIR).filter((f) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(f)).sort();
|
|
396
|
+
} catch {
|
|
397
|
+
return [];
|
|
398
|
+
}
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
function lastHashOfDay(date) {
|
|
402
|
+
return lastHashOf(path.join(AUDIT_DIR, `${date}.jsonl`));
|
|
403
|
+
}
|
|
404
|
+
|
|
405
|
+
// 取「当天 tail」,当天没有就往前找最近一天的 tail(修跨天断链)
|
|
406
|
+
function nextPrevHash(date) {
|
|
407
|
+
const file = path.join(AUDIT_DIR, `${date}.jsonl`);
|
|
408
|
+
const prev = lastHashOf(file);
|
|
409
|
+
if (prev !== "0".repeat(64)) return prev; // 当天有链,正常运行
|
|
410
|
+
// 当天还没有记录:**从 date 前一天起**按日期降序找最近已有 tail,绝不看 future。
|
|
411
|
+
const today = localDate();
|
|
412
|
+
const sorted = auditDayFiles().sort().filter((f) => f.slice(0, 10) < today);
|
|
413
|
+
for (let i = sorted.length - 1; i >= 0; i--) {
|
|
414
|
+
if (sorted[i].slice(0, 10) >= date) continue; // 只能找 date 之前的
|
|
415
|
+
const h = lastHashOf(path.join(AUDIT_DIR, sorted[i]));
|
|
416
|
+
if (h !== "0".repeat(64)) return h;
|
|
417
|
+
}
|
|
418
|
+
return "0".repeat(64);
|
|
419
|
+
}
|
|
420
|
+
// 哈希载荷:除链字段外的全部字段,保持写入/校验口径完全一致
|
|
421
|
+
function auditPayload(rec) {
|
|
422
|
+
const SKIP = new Set(["ts", "type", "sessionID", "prevHash", "hash"]);
|
|
423
|
+
const out = {};
|
|
424
|
+
for (const k of Object.keys(rec)) {
|
|
425
|
+
if (!SKIP.has(k)) out[k] = rec[k];
|
|
426
|
+
}
|
|
427
|
+
return JSON.stringify(out);
|
|
428
|
+
}
|
|
429
|
+
|
|
430
|
+
// 敏感信息脱敏
|
|
431
|
+
//
|
|
432
|
+
// 用户卡片里可能包含密钥/密码(`verify.cmd` 里的 `sk_live_xxx`、`token`、
|
|
433
|
+
// `password`),审计记录也接受任意 `fields`——如果原样落盘,**门禁本身成了泄露源**。
|
|
434
|
+
//
|
|
435
|
+
// 规则:
|
|
436
|
+
// · key 命中 `secret/key/password/pwd/token/credential/auth` 之一(不区分大小写)
|
|
437
|
+
// · 或 string value 里含有 `sk_|secret=|password=|token=|api_key=|sk_live|sk_test`
|
|
438
|
+
// → 记为敏感 value,脱敏:长度 ≤ 8 → `[脱敏]`,否则头尾各保留 4 个字符中间 ***
|
|
439
|
+
//
|
|
440
|
+
// 任何异常都不可抛(`audit` 必须永不抛错),脱敏失败则原地返回原值。
|
|
441
|
+
function isSensitiveKey(k) {
|
|
442
|
+
try {
|
|
443
|
+
return typeof k === "string" && /[Ss]ecret|[Kk]ey|[Pp]assword|[Pp]wd|[Tt]oken|[Cc]redential|[Aa]uth/.test(k);
|
|
444
|
+
} catch {
|
|
445
|
+
return false;
|
|
446
|
+
}
|
|
447
|
+
}
|
|
448
|
+
const SENSITIVE_VALUES_RE = /sk_|secret=|password=|token=|api_key=|sk_live|sk_test|secret:/i;
|
|
449
|
+
function isSensitiveValue(v) {
|
|
450
|
+
try {
|
|
451
|
+
return typeof v === "string" && v.length > 0 && SENSITIVE_VALUES_RE.test(v);
|
|
452
|
+
} catch {
|
|
453
|
+
return false;
|
|
454
|
+
}
|
|
455
|
+
}
|
|
456
|
+
function maskValue(v) {
|
|
457
|
+
try {
|
|
458
|
+
if (typeof v === "string" && v.length > 0) {
|
|
459
|
+
if (v.length <= 8) return "[脱敏]";
|
|
460
|
+
return v.slice(0, 4) + "***" + v.slice(-4);
|
|
461
|
+
}
|
|
462
|
+
return v;
|
|
463
|
+
} catch {
|
|
464
|
+
return v;
|
|
465
|
+
}
|
|
466
|
+
}
|
|
467
|
+
function sanitizeValue(v) {
|
|
468
|
+
try {
|
|
469
|
+
if (Array.isArray(v)) return v.map(sanitizeValue);
|
|
470
|
+
if (v && typeof v === "object") {
|
|
471
|
+
const out = {};
|
|
472
|
+
for (const k of Object.keys(v)) {
|
|
473
|
+
const val = v[k];
|
|
474
|
+
out[k] = isSensitiveKey(k) || isSensitiveValue(val) ? maskValue(val) : sanitizeValue(val);
|
|
475
|
+
}
|
|
476
|
+
return out;
|
|
477
|
+
}
|
|
478
|
+
return v;
|
|
479
|
+
} catch {
|
|
480
|
+
return v;
|
|
481
|
+
}
|
|
482
|
+
}
|
|
483
|
+
export function sanitizeFields(o) {
|
|
484
|
+
return sanitizeValue(o ?? {});
|
|
485
|
+
}
|
|
486
|
+
|
|
487
|
+
|
|
488
|
+
// ---- 审计链哈希模式 ----
|
|
489
|
+
//
|
|
490
|
+
// 裸 SHA-256 哈希链能防的是「**意外**损坏」(截断、位翻转、误删),
|
|
491
|
+
// **防不了有意篡改**:攻击者能读文件,就能重算整条链。
|
|
492
|
+
//
|
|
493
|
+
// 因此提供两种模式:
|
|
494
|
+
// · hmac —— 设置了 CARLOS_FLOW_AUDIT_KEY 时使用带密钥的 HMAC-SHA256。
|
|
495
|
+
// 攻击者没有密钥 → 重算不出正确 hash → 篡改必被发现。
|
|
496
|
+
// · plain —— 未设置密钥时的降级模式(裸 SHA-256),**在 verify 结果里
|
|
497
|
+
// 显式标注 mode**,让调用方知道自己拿到的是哪种保证。
|
|
498
|
+
//
|
|
499
|
+
// 不做「默认启用 HMAC」:没有密钥就签不了名,用户第一次用就会报错。
|
|
500
|
+
// 也不做「假装 HMAC」:plain 模式必须诚实地说自己只是弱保证。
|
|
501
|
+
const AUDIT_KEY = (() => {
|
|
502
|
+
const k = process.env.CARLOS_FLOW_AUDIT_KEY;
|
|
503
|
+
return typeof k === "string" && k.length >= 16 ? k : null;
|
|
504
|
+
})();
|
|
505
|
+
|
|
506
|
+
export function auditHashMode() {
|
|
507
|
+
return AUDIT_KEY ? "hmac" : "plain";
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
// 计算一条记录的 hash(写入与校验必须用同一套函数,否则永远对不上)
|
|
511
|
+
function computeAuditHash(rec, prev) {
|
|
512
|
+
const payload = rec.ts + rec.type + rec.sessionID + auditPayload(rec) + prev;
|
|
513
|
+
if (AUDIT_KEY) {
|
|
514
|
+
return createHmac("sha256", AUDIT_KEY).update(payload).digest("hex");
|
|
515
|
+
}
|
|
516
|
+
return createHash("sha256").update(payload).digest("hex");
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
// 追加审计行;永不抛错,失败仅写 stderr;返回记录对象
|
|
520
|
+
export function audit(type, sid, fields = {}) {
|
|
521
|
+
// 落盘脱敏:用户卡片/审计字段里的密钥片段(verify.cmd 等)不能明文入盘。
|
|
522
|
+
const sanitized = sanitizeFields(fields);
|
|
523
|
+
const rec = {
|
|
524
|
+
ts: new Date().toISOString(),
|
|
525
|
+
type,
|
|
526
|
+
sessionID: sanitizeId(sid),
|
|
527
|
+
...sanitized,
|
|
528
|
+
};
|
|
529
|
+
try {
|
|
530
|
+
fs.mkdirSync(AUDIT_DIR, { recursive: true });
|
|
531
|
+
const file = path.join(AUDIT_DIR, `${localDate()}.jsonl`);
|
|
532
|
+
// 前驱 hash 取自当天文件 tail;当天没有记录时退成分片链上一天的 tail
|
|
533
|
+
//(nextPrevHash),这样审计链在午夜也不断开。
|
|
534
|
+
const prev = nextPrevHash(localDate());
|
|
535
|
+
rec.prevHash = prev;
|
|
536
|
+
rec.hash = computeAuditHash(rec, prev);
|
|
537
|
+
// 单次 appendFileSync:O_APPEND 语义,多进程并发写不会互相截断
|
|
538
|
+
fs.appendFileSync(file, JSON.stringify(rec) + "\n", "utf8");
|
|
539
|
+
} catch (e) {
|
|
540
|
+
try {
|
|
541
|
+
process.stderr.write(`[flow-audit] 写入失败: ${e && e.message ? e.message : e}\n`);
|
|
542
|
+
} catch {}
|
|
543
|
+
}
|
|
544
|
+
return rec;
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
// 校验审计链完整性(可选:需完整文件,不能只看尾部)。
|
|
548
|
+
//
|
|
549
|
+
// 审计文件按天分片(`localDate().jsonl`),审计链是「分片链表」:
|
|
550
|
+
// 前一天最后一条记录的 hash 是后一天第一条记录的 prevHash(nextPrevHash)。
|
|
551
|
+
// 所以默认 `verifyAuditChain()` **逐天串联所有记录** 验证整条链——
|
|
552
|
+
// 攻击者篡改任意一天的任意记录,整链检测都会 break(配合 CARLOS_FLOW_AUDIT_KEY
|
|
553
|
+
// 为 HMAC 时做得到;plain 模式可在推荐结果里看到 mode 降级声明)。
|
|
554
|
+
//
|
|
555
|
+
// `opts.date` 给定的一天 → 只验证那一天(验证起点是前一天 tail,跨天)。
|
|
556
|
+
// `opts.fullChain` 默认 true → 验证全部天的完整链。
|
|
557
|
+
export function verifyAuditChain(opts = {}) {
|
|
558
|
+
const rawDate = typeof opts.date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(opts.date) ? opts.date : localDate();
|
|
559
|
+
// ⚠️ 必须用 rawDate(而不是 localDate())—— 否则 opts.date 完全失效:
|
|
560
|
+
// 传 date='2020-01-01' 读的仍是**今天**的文件,调用方以为在查历史、
|
|
561
|
+
// 实际拿到今天的数据(错而不报,最难发现)。
|
|
562
|
+
const fullChain = typeof opts.fullChain === "boolean" ? opts.fullChain : true;
|
|
563
|
+
if (fullChain && !opts.date) {
|
|
564
|
+
// 全链验证:逐天(按文件名升序 == 升时)串联,每天的 tail 是下一天的 prevHash。
|
|
565
|
+
//
|
|
566
|
+
// 跨天重启容忍(2026-11-14):
|
|
567
|
+
// 写入侧 nextPrevHash() 取「当天文件最后一条**带 hash** 的记录」作为前驱;
|
|
568
|
+
// 若当天先前的记录都是 v2.5 升级上来的 legacy 记录(无 hash),就取不到 tail,
|
|
569
|
+
// 于是这条链首记录的 prevHash 只能是全 0。
|
|
570
|
+
// 这不是篡改,是**合法的链首**。旧校验器一律要求 prevHash === 运行中的 prev,
|
|
571
|
+
// 于是每天的第一条带 hash 记录都被判 broken —— 实测 4 处误报全部是这个形态。
|
|
572
|
+
// 误报比漏报更伤信任(同 legacy 那条注释的口径)。
|
|
573
|
+
//
|
|
574
|
+
// 规则:一天内**第一条带 hash 的记录**若 prevHash 为全 0,
|
|
575
|
+
// 按链首处理 —— 用它自己的 prevHash(全 0)重算 hash,吻合即放行;
|
|
576
|
+
// 从它开始照常串联。计数为 dayRestart,与 broken 分开报,不静默吞掉。
|
|
577
|
+
const files = auditDayFiles();
|
|
578
|
+
const byDay = [];
|
|
579
|
+
let total = 0, broken = 0, legacy = 0, restart = 0;
|
|
580
|
+
const brokenAt = [];
|
|
581
|
+
let prev = ZERO_HASH; // 链起点
|
|
582
|
+
for (const f of files) {
|
|
583
|
+
let raw = "";
|
|
584
|
+
try {
|
|
585
|
+
raw = fs.readFileSync(path.join(AUDIT_DIR, f), "utf8");
|
|
586
|
+
} catch {
|
|
587
|
+
continue;
|
|
588
|
+
}
|
|
589
|
+
let dayBroken = 0, dayLegacy = 0, dayRestart = 0;
|
|
590
|
+
let hashedSeen = 0;
|
|
591
|
+
for (const line of raw.split("\n")) {
|
|
592
|
+
const t = line.trim();
|
|
593
|
+
if (!t) continue;
|
|
594
|
+
let r;
|
|
595
|
+
try {
|
|
596
|
+
r = JSON.parse(t);
|
|
597
|
+
} catch {
|
|
598
|
+
continue;
|
|
599
|
+
}
|
|
600
|
+
total++;
|
|
601
|
+
if (typeof r.hash !== "string") {
|
|
602
|
+
// 旧格式记录(无 hash)→ 计入 legacy 计数,但**不重置链起点**
|
|
603
|
+
legacy++;
|
|
604
|
+
dayLegacy++;
|
|
605
|
+
continue;
|
|
606
|
+
}
|
|
607
|
+
hashedSeen++;
|
|
608
|
+
// 一天内的首条带 hash 记录且 prevHash 为全 0 → 合法链首(见上)。
|
|
609
|
+
const isDayStart = hashedSeen === 1 && r.prevHash === ZERO_HASH;
|
|
610
|
+
const base = isDayStart ? ZERO_HASH : prev;
|
|
611
|
+
const expect = computeAuditHash(r, base);
|
|
612
|
+
if (isDayStart) {
|
|
613
|
+
// 只有当它自己的 hash 确实是用全 0 前驱算出来的才算合法链首;
|
|
614
|
+
// 否则仍按 broken 处理(防「把任意记录伪装成链首」)。
|
|
615
|
+
if (expect === r.hash) {
|
|
616
|
+
restart++;
|
|
617
|
+
dayRestart++;
|
|
618
|
+
prev = r.hash;
|
|
619
|
+
continue;
|
|
620
|
+
}
|
|
621
|
+
}
|
|
622
|
+
if (expect !== r.hash || r.prevHash !== base) {
|
|
623
|
+
broken++;
|
|
624
|
+
dayBroken++;
|
|
625
|
+
if (brokenAt.length < 10) brokenAt.push({ date: f.slice(0, 10), ts: r.ts, type: r.type, kind: r.kind });
|
|
626
|
+
}
|
|
627
|
+
prev = r.hash;
|
|
628
|
+
}
|
|
629
|
+
byDay.push({ date: f.slice(0, 10), dayBroken, dayLegacy, dayRestart, tailHash: prev });
|
|
630
|
+
}
|
|
631
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
632
|
+
ok: broken === 0, total, broken, legacy, restart, brokenAt, byDay, mode: auditHashMode(),
|
|
633
|
+
note: "全链验证:逐天串联,每天的 tail 是下一天的前驱。dayRestart 为「当天首条带 hash 记录以全 0 前驱合法起链」的处数,不是篡改。",
|
|
634
|
+
};
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
// 单日验证:按 date 读一天文件,链起点用前一天 tail(跨天联动)或全 0(新链第一天)。
|
|
638
|
+
const file = path.join(AUDIT_DIR, `${rawDate}.jsonl`);
|
|
639
|
+
let raw = "";
|
|
640
|
+
try {
|
|
641
|
+
raw = fs.readFileSync(file, "utf8");
|
|
642
|
+
} catch {
|
|
643
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: true, total: 0, broken: 0, legacy: 0, brokenAt: [], file, mode: auditHashMode() };
|
|
644
|
+
}
|
|
645
|
+
// 单日的链起点:前一个 tail hash(跨天)或全 0(新链第一天)。
|
|
646
|
+
const files = auditDayFiles();
|
|
647
|
+
let prev = "0".repeat(64);
|
|
648
|
+
for (const f of files) {
|
|
649
|
+
if (f === `${rawDate}.jsonl`) break;
|
|
650
|
+
prev = lastHashOf(path.join(AUDIT_DIR, f));
|
|
651
|
+
}
|
|
652
|
+
let total = 0, broken = 0, legacy = 0;
|
|
653
|
+
const brokenAt = [];
|
|
654
|
+
for (const line of raw.split("\n")) {
|
|
655
|
+
const t = line.trim();
|
|
656
|
+
if (!t) continue;
|
|
657
|
+
let r;
|
|
658
|
+
try {
|
|
659
|
+
r = JSON.parse(t);
|
|
660
|
+
} catch {
|
|
661
|
+
continue;
|
|
662
|
+
}
|
|
663
|
+
total++;
|
|
664
|
+
if (typeof r.hash !== "string") {
|
|
665
|
+
// 旧格式记录(无 hash)→ 计入 legacy 计数,但**不重置链起点**。
|
|
666
|
+
//
|
|
667
|
+
// 早先这里写的是 prev = "0".repeat(64),于是**一条**旧记录就会让
|
|
668
|
+
// 它之后所有记录的 prevHash 全部对不上 → 全判 broken。
|
|
669
|
+
// 后果:v2.5 升级上来的用户,审计链校验会长期报红,
|
|
670
|
+
// 而 README 把「可验证审计链」列为核心能力 —— 用户会以为自己的
|
|
671
|
+
// 审计记录被篡改了。**漏报比误报可接受,误报更伤信任。**
|
|
672
|
+
legacy++;
|
|
673
|
+
continue;
|
|
674
|
+
}
|
|
675
|
+
const expect = computeAuditHash(r, prev);
|
|
676
|
+
if (expect !== r.hash || r.prevHash !== prev) {
|
|
677
|
+
broken++;
|
|
678
|
+
if (brokenAt.length < 10) brokenAt.push({ ts: r.ts, type: r.type, kind: r.kind });
|
|
679
|
+
}
|
|
680
|
+
prev = r.hash;
|
|
681
|
+
}
|
|
682
|
+
// mode 字段说明本次校验的**保证强度**:
|
|
683
|
+
// hmac → 带密钥(CARLOS_FLOW_AUDIT_KEY),能发现有意篡改
|
|
684
|
+
// plain → 裸 SHA-256,只能发现意外损坏(攻击者能重算整条链)
|
|
685
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: broken === 0, total, broken, legacy, brokenAt, file, mode: auditHashMode() };
|
|
686
|
+
}
|
|
687
|
+
|
|
688
|
+
|
|
689
|
+
export function readAudit(opts = {}) {
|
|
690
|
+
const { sessionId, type, limit } = opts;
|
|
691
|
+
const rawDate = typeof opts.date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(opts.date) ? opts.date : localDate();
|
|
692
|
+
try {
|
|
693
|
+
// ⚠️ 必须用 rawDate(而不是 localDate())—— 否则 opts.date 完全失效。
|
|
694
|
+
const file = path.join(AUDIT_DIR, `${rawDate}.jsonl`);
|
|
695
|
+
const raw = fs.readFileSync(file, "utf8");
|
|
696
|
+
const out = [];
|
|
697
|
+
for (const line of raw.split("\n")) {
|
|
698
|
+
const t = line.trim();
|
|
699
|
+
if (!t) continue;
|
|
700
|
+
let rec;
|
|
701
|
+
try {
|
|
702
|
+
rec = JSON.parse(t);
|
|
703
|
+
} catch {
|
|
704
|
+
continue; // 坏行跳过
|
|
705
|
+
}
|
|
706
|
+
if (sessionId != null && rec.sessionID !== sanitizeId(sessionId)) continue;
|
|
707
|
+
if (type != null && rec.type !== type) continue;
|
|
708
|
+
out.push(rec);
|
|
709
|
+
}
|
|
710
|
+
if (typeof limit === "number" && limit >= 0) return out.slice(-limit); // 取最近 N 条
|
|
711
|
+
return out;
|
|
712
|
+
} catch {
|
|
713
|
+
return [];
|
|
714
|
+
}
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
// 从用户消息源读取原文(quote 锚点数据源)。
|
|
718
|
+
// 三个来源按优先级合并:
|
|
719
|
+
// 1. $CARLOS_USER_MSGS —— 启动时注入的 JSON 数组(最直接)
|
|
720
|
+
// 2. RUNS_DIR/<sid>/user_msgs.jsonl —— 本会话写入的用户原话(Cindy 路径)
|
|
721
|
+
// 3. OpenCode SQLite —— 宿主是 OpenCode 时直接读它的会话库
|
|
722
|
+
// 任何异常 → 返回 null,绝不抛错。
|
|
723
|
+
export async function getUserMessages(sid, limit = 20) {
|
|
724
|
+
const out = [];
|
|
725
|
+
|
|
726
|
+
// 1. 环境变量注入
|
|
727
|
+
try {
|
|
728
|
+
const envMsgs = process.env.CARLOS_USER_MSGS;
|
|
729
|
+
if (envMsgs) {
|
|
730
|
+
const arr = JSON.parse(envMsgs);
|
|
731
|
+
if (Array.isArray(arr)) {
|
|
732
|
+
for (const m of arr) if (typeof m === "string" && m !== "") out.push(m);
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
} catch {}
|
|
736
|
+
|
|
737
|
+
// 2. 会话目录里的 user_msgs.jsonl
|
|
738
|
+
try {
|
|
739
|
+
const file = path.join(RUNS_DIR, sanitizeId(sid), "user_msgs.jsonl");
|
|
740
|
+
if (fs.existsSync(file)) {
|
|
741
|
+
const raw = fs.readFileSync(file, "utf8");
|
|
742
|
+
for (const line of raw.split("\n")) {
|
|
743
|
+
const t = line.trim();
|
|
744
|
+
if (!t) continue;
|
|
745
|
+
try {
|
|
746
|
+
const rec = JSON.parse(t);
|
|
747
|
+
if (rec && typeof rec.text === "string" && rec.text !== "") out.push(rec.text);
|
|
748
|
+
} catch {}
|
|
749
|
+
}
|
|
750
|
+
}
|
|
751
|
+
} catch {}
|
|
752
|
+
|
|
753
|
+
// 3. OpenCode 会话库(宿主是 OpenCode 时的权威来源)
|
|
754
|
+
const fromOpenCode = await getOpenCodeUserMessages(sid, limit);
|
|
755
|
+
if (fromOpenCode && fromOpenCode.length) out.push(...fromOpenCode);
|
|
756
|
+
|
|
757
|
+
if (!out.length) return null;
|
|
758
|
+
return out.slice(-limit);
|
|
759
|
+
}
|
|
760
|
+
|
|
761
|
+
// 从 OpenCode 的 SQLite 会话库读用户原话。
|
|
762
|
+
// 路径可用 OPENCODE_DB_PATH / OPENCODE_DB 覆盖,默认 ~/.local/share/opencode/opencode.db。
|
|
763
|
+
// 任何异常(node:sqlite 不可用 / 库不存在 / 表结构变化)→ 返回 null,绝不抛错。
|
|
764
|
+
export async function getOpenCodeUserMessages(sid, limit = 20) {
|
|
765
|
+
let db = null;
|
|
766
|
+
try {
|
|
767
|
+
const mod = await import("node:sqlite");
|
|
768
|
+
const DatabaseSync = mod && mod.DatabaseSync;
|
|
769
|
+
if (typeof DatabaseSync !== "function") return null;
|
|
770
|
+
const dbPath = resolveOpenCodeDb();
|
|
771
|
+
if (!dbPath) return null;
|
|
772
|
+
try {
|
|
773
|
+
db = new DatabaseSync(dbPath, { readOnly: true });
|
|
774
|
+
} catch {
|
|
775
|
+
db = new DatabaseSync(dbPath, { readonly: true }); // 选项名兜底
|
|
776
|
+
}
|
|
777
|
+
let sql =
|
|
778
|
+
"SELECT p.data AS d FROM part p JOIN message m ON p.message_id=m.id" +
|
|
779
|
+
" WHERE json_extract(m.data,'$.role')='user' AND json_extract(p.data,'$.type')='text'";
|
|
780
|
+
const params = [];
|
|
781
|
+
if (sid) {
|
|
782
|
+
sql += " AND m.session_id=?";
|
|
783
|
+
params.push(sid);
|
|
784
|
+
}
|
|
785
|
+
sql += " ORDER BY p.time_created DESC LIMIT ?";
|
|
786
|
+
params.push(limit);
|
|
787
|
+
const rows = db.prepare(sql).all(...params);
|
|
788
|
+
const out = [];
|
|
789
|
+
for (const row of rows) {
|
|
790
|
+
let parsed;
|
|
791
|
+
try {
|
|
792
|
+
parsed = JSON.parse(row.d);
|
|
793
|
+
} catch {
|
|
794
|
+
continue;
|
|
795
|
+
}
|
|
796
|
+
const text = parsed && parsed.text;
|
|
797
|
+
if (typeof text === "string" && text !== "") out.push(text);
|
|
798
|
+
}
|
|
799
|
+
return out;
|
|
800
|
+
} catch {
|
|
801
|
+
return null;
|
|
802
|
+
} finally {
|
|
803
|
+
if (db) {
|
|
804
|
+
try {
|
|
805
|
+
db.close();
|
|
806
|
+
} catch {}
|
|
807
|
+
}
|
|
808
|
+
}
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
// 写入用户消息到会话目录(供 quote 锚点校验使用)
|
|
812
|
+
export function writeUserMessage(sid, text) {
|
|
813
|
+
try {
|
|
814
|
+
const dir = path.join(RUNS_DIR, sanitizeId(sid));
|
|
815
|
+
fs.mkdirSync(dir, { recursive: true });
|
|
816
|
+
const file = path.join(dir, "user_msgs.jsonl");
|
|
817
|
+
const rec = JSON.stringify({ ts: new Date().toISOString(), text }) + "\n";
|
|
818
|
+
fs.appendFileSync(file, rec, "utf8");
|
|
819
|
+
return true;
|
|
820
|
+
} catch {
|
|
821
|
+
return false;
|
|
822
|
+
}
|
|
823
|
+
}
|
|
824
|
+
|
|
825
|
+
export function pathExists(cwd, p) {
|
|
826
|
+
const abs = path.isAbsolute(p) ? p : path.join(cwd || process.cwd(), p);
|
|
827
|
+
return fs.existsSync(abs);
|
|
828
|
+
}
|
|
829
|
+
|
|
830
|
+
export function gitHead(cwd) {
|
|
831
|
+
try {
|
|
832
|
+
const r = spawnSync("git", ["rev-parse", "HEAD"], {
|
|
833
|
+
cwd: cwd || process.cwd(),
|
|
834
|
+
encoding: "utf8",
|
|
835
|
+
shell: false,
|
|
836
|
+
});
|
|
837
|
+
return r.status === 0 ? String(r.stdout || "").trim() : "";
|
|
838
|
+
} catch {
|
|
839
|
+
return "";
|
|
840
|
+
}
|
|
841
|
+
}
|
|
842
|
+
|
|
843
|
+
// card_ts 距今超过 ttlSec → true;无卡(card_ts 缺失/0)不视为过期
|
|
844
|
+
export function isStale(state, ttlSec = 14400) {
|
|
845
|
+
const ts = state ? Number(state.card_ts) : 0;
|
|
846
|
+
if (!ts) return false;
|
|
847
|
+
return Date.now() - ts > ttlSec * 1000;
|
|
848
|
+
}
|
|
849
|
+
|
|
850
|
+
// Phase 1-1: 检查 bypass 是否启用
|
|
851
|
+
export function isBypassed(state) {
|
|
852
|
+
if (!state || state.bypass !== true) return false;
|
|
853
|
+
// 免检必须显式开启(bypass_ts 有值)且发生在当前卡片之后,
|
|
854
|
+
// 否则旧卡片的免检状态会错误地作用于新卡片
|
|
855
|
+
if (!state.bypass_ts) return false;
|
|
856
|
+
if (state.card_ts && state.bypass_ts < state.card_ts) return false;
|
|
857
|
+
return true;
|
|
858
|
+
}
|
|
859
|
+
|
|
860
|
+
// ---------------------------------------------------------------------------
|
|
861
|
+
// workspaceFingerprint —— 工作区代码状态指纹
|
|
862
|
+
//
|
|
863
|
+
// 为什么需要(A1):
|
|
864
|
+
// 原来的 PASS 闸门只看 last_verify 的三个字段(存在 / ok===true / cmd 与卡片一致),
|
|
865
|
+
// **不绑定代码状态**。于是存在这条绕过路径:
|
|
866
|
+
// 1. flow_run_verify 跑通 → last_verify = {ok:true, cmd:"npm test"}
|
|
867
|
+
// 2. executor 继续改代码(甚至改坏)
|
|
868
|
+
// 3. flow_verdict(PASS) → 三个条件全满足 → 放行
|
|
869
|
+
// 指纹把「验证通过」绑定到**一次可复现的运行**:验证之后再动过代码,指纹就变了。
|
|
870
|
+
//
|
|
871
|
+
// 指纹构成:HEAD 提交 + `git diff HEAD` 的全文 + 全部未跟踪文件(路径 + 内容)。
|
|
872
|
+
// · 未跟踪文件必须计入:新建文件是最常见的越界/破坏手段。
|
|
873
|
+
// · `.carlos-flow/` 必须排除:跑一次检查会创建状态目录,计入则立即自我失效。
|
|
874
|
+
//
|
|
875
|
+
// 非 git 目录:显式返回 {ok:false, reason:"not_a_git_repo"},**不崩**。
|
|
876
|
+
// Carlos Flow 明确支持非 Git 项目,所以调用方要 fail-open(不阻断 PASS),
|
|
877
|
+
// 但要在 flow_status 里如实标注指纹不可用。
|
|
878
|
+
export function workspaceFingerprint(cwd) {
|
|
879
|
+
const dir = cwd || process.cwd();
|
|
880
|
+
const head = spawnSync("git", ["rev-parse", "HEAD"], { cwd: dir, encoding: "utf8" });
|
|
881
|
+
if (head.error || head.status !== 0) {
|
|
882
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null, ok: false, reason: "not_a_git_repo" };
|
|
883
|
+
}
|
|
884
|
+
const diff = spawnSync("git", ["diff", "HEAD", "--no-color"], { cwd: dir, encoding: "utf8" });
|
|
885
|
+
const untracked = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
|
|
886
|
+
cwd: dir,
|
|
887
|
+
encoding: "utf8",
|
|
888
|
+
});
|
|
889
|
+
|
|
890
|
+
const h = createHash("sha256");
|
|
891
|
+
h.update(String(diff.stdout || ""));
|
|
892
|
+
|
|
893
|
+
const files = String(untracked.stdout || "")
|
|
894
|
+
.split("\n")
|
|
895
|
+
.map((s) => s.trim())
|
|
896
|
+
.filter(Boolean)
|
|
897
|
+
.sort();
|
|
898
|
+
|
|
899
|
+
// 状态目录必须排除(R3):跑一次检查就会往里写审计/状态文件,
|
|
900
|
+
// 若计入指纹则「验证 → 落审计 → 记裁定」之间指纹必变 → 每次都误报 STALE。
|
|
901
|
+
//
|
|
902
|
+
// ⚠️ 不能只硬编码 ".carlos-flow/":状态目录由 CARLOS_FLOW_HOME 决定,
|
|
903
|
+
// 用户完全可以把它设在**项目内部**(如 <repo>/.flowhome),那就会自我失效。
|
|
904
|
+
// 所以这里按**解析后的绝对路径**排除真正的 FLOW_HOME,
|
|
905
|
+
// 同时保留 .carlos-flow/ 的字面排除以兼容默认布局。
|
|
906
|
+
const flowHomeAbs = path.resolve(FLOW_HOME);
|
|
907
|
+
for (const f of files) {
|
|
908
|
+
const abs = path.resolve(dir, f);
|
|
909
|
+
const inFlowHome = abs === flowHomeAbs || abs.startsWith(flowHomeAbs + path.sep);
|
|
910
|
+
if (inFlowHome) continue;
|
|
911
|
+
if (f.startsWith(".carlos-flow/") || f.startsWith(".carlos-flow\\")) continue;
|
|
912
|
+
h.update(`\u0000untracked-file:${f}\u0000`);
|
|
913
|
+
try {
|
|
914
|
+
const buf = fs.readFileSync(path.join(dir, f));
|
|
915
|
+
// 大文件只入路径 + 大小,不入内容(避免读上万文件/大文件)
|
|
916
|
+
if (buf.length > 1024 * 1024) {
|
|
917
|
+
h.update(`size:${buf.length}`);
|
|
918
|
+
} else {
|
|
919
|
+
h.update(buf);
|
|
920
|
+
}
|
|
921
|
+
} catch (e) {
|
|
922
|
+
h.update(`<<unreadable: ${e}>>`);
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
|
|
926
|
+
return { mode: "pro", mode_ts: 0, claimed_profile: null,
|
|
927
|
+
ok: true,
|
|
928
|
+
head: String(head.stdout || "").trim(),
|
|
929
|
+
diff_sha256: h.digest("hex"),
|
|
930
|
+
};
|
|
931
931
|
}
|