mingdao-harness 0.6.28 → 0.6.30
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/README.en.md +1 -1
- package/SECURITY.md +1 -1
- package/docs/ARCHITECTURE.md +4 -4
- package/docs/CONFIG.md +62 -4
- package/package.json +1 -1
- package/src/agent.js +128 -37
- package/src/atomic-write.js +80 -4
- package/src/cachestats.js +20 -11
- package/src/context.js +139 -2
- package/src/credentials.js +29 -3
- package/src/ledger.js +30 -1
- package/src/memory.js +126 -33
- package/src/model-discovery.js +2 -0
- package/src/net-guard.js +103 -6
- package/src/permissions.js +350 -8
- package/src/pricing.js +60 -34
- package/src/providers/openai-compatible.js +120 -33
- package/src/redact.js +92 -4
- package/src/regex-safety.js +645 -51
- package/src/safe-fetch.js +59 -8
- package/src/session-index.js +287 -81
- package/src/session.js +74 -19
- package/src/sync-server.js +867 -118
- package/src/sync.js +25 -1
- package/src/task-state.js +44 -21
- package/src/tools/bash.js +7 -13
- package/src/tools/fs-tools.js +25 -28
- package/src/tools/git.js +174 -29
- package/src/tools/index.js +19 -3
- package/src/web/routes/domains/config.js +44 -12
- package/src/web/routes/domains/misc.js +43 -13
- package/src/web/routes/domains/sessions.js +3 -2
- package/src/web/server.js +254 -68
package/src/cachestats.js
CHANGED
|
@@ -341,6 +341,20 @@ export function costBreakdown() {
|
|
|
341
341
|
// v0.5.0 A4:垂域 Pack 分账(来自 ctx.llm 的标记记录;cost 为 null 不入总额,取 packCost 展示)
|
|
342
342
|
const byPack = /** @type {Map<string, {prompt: number, completion: number, cost: number, calls: number}>} */ (new Map());
|
|
343
343
|
const start = beijingDayStart().getTime();
|
|
344
|
+
// v0.6.31(核验报告 H-1):byDay **预计算 14 个北京日界再分桶**(此前每条记录一次
|
|
345
|
+
// beijingParts → 2 万条 = 2 万次 ICU 格式化,单请求阻塞 0.85~8.16 秒)。
|
|
346
|
+
// 日界本身用 beijingDayStart 算(与旧实现「start - i*86400000 → beijingParts」同一个自然日,
|
|
347
|
+
// 跨夏令时也一致);分桶只用数值比较,与记录条数线性相关。
|
|
348
|
+
const DAYS = 14;
|
|
349
|
+
/** @type {number[]} */
|
|
350
|
+
const dayBounds = [];
|
|
351
|
+
for (let i = DAYS - 1; i >= 0; i--) dayBounds.push(beijingDayStart(new Date(start - i * 86400000)).getTime());
|
|
352
|
+
// 明日 0 点(+36h 跨过夏令时 23/25 小时日):未来日记录在旧实现里 key 也不在输出窗口,直接排除。
|
|
353
|
+
const tomorrowStart = beijingDayStart(new Date(start + 36 * 3600000)).getTime();
|
|
354
|
+
const dayKeys = dayBounds.map((t) => {
|
|
355
|
+
const p = beijingParts(new Date(t));
|
|
356
|
+
return `${String(p.month).padStart(2, '0')}-${String(p.day).padStart(2, '0')}`;
|
|
357
|
+
});
|
|
344
358
|
let totalCost = 0;
|
|
345
359
|
let totalSaved = 0;
|
|
346
360
|
let today = 0;
|
|
@@ -381,20 +395,15 @@ export function costBreakdown() {
|
|
|
381
395
|
byTool.set(t.tool, tt);
|
|
382
396
|
}
|
|
383
397
|
}
|
|
384
|
-
if (e.at) {
|
|
385
|
-
|
|
386
|
-
|
|
398
|
+
if (e.at && e.at >= dayBounds[0] && e.at < tomorrowStart) {
|
|
399
|
+
let idx = DAYS - 1;
|
|
400
|
+
while (idx > 0 && e.at < dayBounds[idx]) idx -= 1;
|
|
401
|
+
const key = dayKeys[idx];
|
|
387
402
|
byDay.set(key, (byDay.get(key) || 0) + (e.cost || 0));
|
|
388
403
|
}
|
|
389
404
|
}
|
|
390
|
-
//
|
|
391
|
-
const days =
|
|
392
|
-
for (let i = 13; i >= 0; i--) {
|
|
393
|
-
const d = new Date(start - i * 86400000);
|
|
394
|
-
const p = beijingParts(d);
|
|
395
|
-
const key = `${String(p.month).padStart(2, '0')}-${String(p.day).padStart(2, '0')}`;
|
|
396
|
-
days.push({ day: key, cost: byDay.get(key) || 0 });
|
|
397
|
-
}
|
|
405
|
+
// 折线 x 轴连续(含无记录的 0 值日):key 与旧实现逐条一致
|
|
406
|
+
const days = dayKeys.map((day) => ({ day, cost: byDay.get(day) || 0 }));
|
|
398
407
|
return {
|
|
399
408
|
totalCost,
|
|
400
409
|
totalSaved,
|
package/src/context.js
CHANGED
|
@@ -24,8 +24,65 @@ export function approxTokens(/** @type {any} */ text) {
|
|
|
24
24
|
return heuristicTokens(text);
|
|
25
25
|
}
|
|
26
26
|
|
|
27
|
+
// —— 多模态 content parts 的 token 估值口径(审计 v0.6.29 C-02 / 严重-2)——
|
|
28
|
+
// 旧实现在 content 为数组时走 `count(String(array))` → 只数到 "[object Object]"(13 token),
|
|
29
|
+
// 一条 200KB 的图文消息在预算/压缩/费用护栏里几乎是免费的,真实请求却可能直接超窗。
|
|
30
|
+
// 现在的口径(**宁可高估、不可漏计**):
|
|
31
|
+
// · text / input_text:交给现有计数器 count()——有词表走 BPE,无词表走启发式
|
|
32
|
+
// (英文≈4 字符/token、CJK≈1 字符/token),与纯文本字符串消息**同一口径**;
|
|
33
|
+
// · image_url / image / input_image:固定 2048 token/个。视觉开销取决于解码后的像素与
|
|
34
|
+
// 分块,无法从 base64 长度反推(同一张图 base64 可差数倍),故取保守占位:
|
|
35
|
+
// OpenAI high detail(85 + 170×tiles)常见 ≈1,105、Anthropic((w×h)/750)≈1,365,
|
|
36
|
+
// 2048 覆盖 2K 级截图;也远大于旧实现的 13;
|
|
37
|
+
// · input_audio / audio:固定 1024 token/个(1 分钟 16kHz 语音的常见计费量级);
|
|
38
|
+
// · 未知 part:取 max(2048, 序列化长度/4)——既覆盖未知媒体,也避免把未知大对象当免费;
|
|
39
|
+
// · 非数组对象(部分网关把 content 包成对象):按 JSON 序列化后计数,绝不 String() 成
|
|
40
|
+
// "[object Object]"。
|
|
41
|
+
const IMAGE_PART_TOKENS = 2048;
|
|
42
|
+
const AUDIO_PART_TOKENS = 1024;
|
|
43
|
+
|
|
44
|
+
function contentTokens(/** @type {any} */ content, /** @type {any} */ count) {
|
|
45
|
+
if (typeof content === 'string') return count(content);
|
|
46
|
+
if (Array.isArray(content)) {
|
|
47
|
+
let total = 0;
|
|
48
|
+
for (const part of content) {
|
|
49
|
+
if (part == null) continue;
|
|
50
|
+
if (typeof part === 'string') {
|
|
51
|
+
total += count(part);
|
|
52
|
+
continue;
|
|
53
|
+
}
|
|
54
|
+
const type = String(part.type || '');
|
|
55
|
+
if (type === 'text' || type === 'input_text' || (!type && typeof part.text === 'string')) {
|
|
56
|
+
total += count(String(part.text ?? ''));
|
|
57
|
+
} else if (type === 'image_url' || type === 'image' || type === 'input_image') {
|
|
58
|
+
total += IMAGE_PART_TOKENS;
|
|
59
|
+
} else if (type === 'input_audio' || type === 'audio') {
|
|
60
|
+
total += AUDIO_PART_TOKENS;
|
|
61
|
+
} else {
|
|
62
|
+
let serialized = '';
|
|
63
|
+
try {
|
|
64
|
+
serialized = JSON.stringify(part) ?? '';
|
|
65
|
+
} catch {
|
|
66
|
+
serialized = '';
|
|
67
|
+
}
|
|
68
|
+
total += Math.max(IMAGE_PART_TOKENS, Math.ceil(serialized.length / 4));
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
return total;
|
|
72
|
+
}
|
|
73
|
+
if (content == null) return 0;
|
|
74
|
+
if (typeof content === 'object') {
|
|
75
|
+
try {
|
|
76
|
+
return count(JSON.stringify(content) ?? '');
|
|
77
|
+
} catch {
|
|
78
|
+
return 0;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
return count(String(content));
|
|
82
|
+
}
|
|
83
|
+
|
|
27
84
|
function partTokens(/** @type {any} */ msg, /** @type {any} */ count) {
|
|
28
|
-
let total =
|
|
85
|
+
let total = contentTokens(msg.content, count);
|
|
29
86
|
for (const tc of msg.tool_calls || []) {
|
|
30
87
|
total += count(JSON.stringify(tc));
|
|
31
88
|
}
|
|
@@ -82,6 +139,65 @@ export function cleanToolPairing(/** @type {any} */ kept) {
|
|
|
82
139
|
});
|
|
83
140
|
}
|
|
84
141
|
|
|
142
|
+
// —— 单条超预算消息的就地截断(审计 v0.6.29 H-01 / 高-1)——
|
|
143
|
+
// 尾部贪心遇到"单条即超预算"时不能直接 break:那样最新一条用户消息会被整条丢弃,
|
|
144
|
+
// 只剩 system,模型对着空气作答,而界面上看不出任何异常。这里的约定是**消息必留**,
|
|
145
|
+
// 放不下就按字符二分截断,并追加可见标注——"被截断"必须让模型和用户都看得见。
|
|
146
|
+
const TRUNCATED_MARK = '…(已截断)';
|
|
147
|
+
|
|
148
|
+
/** 取不超过 allowedTokens 的最长字符前缀(码点安全;兼容 BPE 与启发式计数器)。 */
|
|
149
|
+
function prefixWithin(/** @type {string} */ text, /** @type {number} */ allowedTokens, /** @type {any} */ count) {
|
|
150
|
+
if (count(text) <= allowedTokens) return text;
|
|
151
|
+
let lo = 0;
|
|
152
|
+
let hi = text.length;
|
|
153
|
+
let best = 0;
|
|
154
|
+
while (lo <= hi) {
|
|
155
|
+
const mid = (lo + hi) >> 1;
|
|
156
|
+
if (count(safeHead(text, mid)) <= allowedTokens) {
|
|
157
|
+
best = mid;
|
|
158
|
+
lo = mid + 1;
|
|
159
|
+
} else {
|
|
160
|
+
hi = mid - 1;
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
return safeHead(text, best);
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
/** 把任意 content 截到 allowedTokens 内,返回新 content(字符串或 parts 数组),绝不返回空。 */
|
|
167
|
+
function truncateContent(/** @type {any} */ content, /** @type {number} */ allowedTokens, /** @type {any} */ count) {
|
|
168
|
+
const markTokens = count(TRUNCATED_MARK);
|
|
169
|
+
if (typeof content === 'string') {
|
|
170
|
+
if (count(content) <= allowedTokens) return content;
|
|
171
|
+
if (allowedTokens <= markTokens) return TRUNCATED_MARK;
|
|
172
|
+
return prefixWithin(content, allowedTokens - markTokens, count) + TRUNCATED_MARK;
|
|
173
|
+
}
|
|
174
|
+
if (Array.isArray(content)) {
|
|
175
|
+
// parts 数组:按原序保留能放下的 part;第一个放不下的 text part 就地截断,
|
|
176
|
+
// 媒体 part 放不下则丢弃;末尾统一补一个可见的 text 标注(不破坏 parts 结构)。
|
|
177
|
+
let remaining = Math.max(0, allowedTokens - markTokens);
|
|
178
|
+
const out = [];
|
|
179
|
+
for (const part of content) {
|
|
180
|
+
if (part == null) continue;
|
|
181
|
+
const t = contentTokens([part], count);
|
|
182
|
+
if (t <= remaining) {
|
|
183
|
+
out.push(part);
|
|
184
|
+
remaining -= t;
|
|
185
|
+
continue;
|
|
186
|
+
}
|
|
187
|
+
if (typeof part === 'object' && typeof part.text === 'string') {
|
|
188
|
+
out.push({ ...part, text: prefixWithin(part.text, remaining, count) });
|
|
189
|
+
remaining = 0;
|
|
190
|
+
}
|
|
191
|
+
break;
|
|
192
|
+
}
|
|
193
|
+
out.push({ type: 'text', text: TRUNCATED_MARK });
|
|
194
|
+
return out;
|
|
195
|
+
}
|
|
196
|
+
// 其他形态(对象/number 等):转成 JSON 文本再走字符串截断
|
|
197
|
+
const text = content == null ? '' : JSON.stringify(content) ?? String(content);
|
|
198
|
+
return truncateContent(text, allowedTokens, count);
|
|
199
|
+
}
|
|
200
|
+
|
|
85
201
|
export function trimMessages(/** @type {any} */ messages, /** @type {any} */ budget, count = approxTokens) {
|
|
86
202
|
if (!messages.length) return [];
|
|
87
203
|
const hasSystem = messages[0]?.role === 'system';
|
|
@@ -131,7 +247,28 @@ export function trimMessages(/** @type {any} */ messages, /** @type {any} */ bud
|
|
|
131
247
|
// 回收后仍超预算 → 从尾部保留(必要时继续丢弃最老,清洗 tool 配对)
|
|
132
248
|
total = sysTokens;
|
|
133
249
|
const tail = [];
|
|
134
|
-
|
|
250
|
+
// 不变量(审计 H-01):**最后一条消息必留**。它通常是本轮最新的用户输入;
|
|
251
|
+
// 旧实现从尾往前贪心、首条放不下就 break,单条超预算时结果只剩 system——
|
|
252
|
+
// 模型看不到问题却照常作答,这是"静默失忆"里最危险的一种。
|
|
253
|
+
const lastIndex = out.length - 1;
|
|
254
|
+
if (lastIndex >= 0) {
|
|
255
|
+
const last = out[lastIndex];
|
|
256
|
+
const t = messageTokens(last, count);
|
|
257
|
+
if (total + t <= budget) {
|
|
258
|
+
tail.unshift(last);
|
|
259
|
+
total += t;
|
|
260
|
+
} else {
|
|
261
|
+
// 单条即超预算:就地截断 + 可见标注(不丢消息)。扣掉该消息 4 token 的协议开销。
|
|
262
|
+
const allowed = Math.max(0, budget - total - 4);
|
|
263
|
+
const canTruncate = typeof last.content === 'string' || Array.isArray(last.content);
|
|
264
|
+
const fitted = canTruncate ? { ...last, content: truncateContent(last.content, allowed, count) } : last;
|
|
265
|
+
tail.unshift(fitted);
|
|
266
|
+
total += messageTokens(fitted, count);
|
|
267
|
+
// 截断后仍可能略超预算(标注本身需要 token,且 content 之外还有 tool_calls)——
|
|
268
|
+
// 这里**宁可超一点也保留**,绝不因为放不下而整条丢弃。
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
for (let i = out.length - 2; i >= 0; i--) {
|
|
135
272
|
const t = messageTokens(out[i], count);
|
|
136
273
|
if (total + t > budget) break;
|
|
137
274
|
total += t;
|
package/src/credentials.js
CHANGED
|
@@ -10,6 +10,18 @@ import fs from 'node:fs';
|
|
|
10
10
|
import path from 'node:path';
|
|
11
11
|
import { mingdaoHome, ensureHome } from './config.js';
|
|
12
12
|
import { atomicWriteFileSync } from './atomic-write.js';
|
|
13
|
+
import { redactSecrets } from './redact.js';
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* 值级脱敏(凭证库错误/诊断文本用)。
|
|
17
|
+
*
|
|
18
|
+
* **不在本文件维护第二份前缀表**:规则唯一来源是 `redact.js` 的 `SECRET_VALUE_PATTERNS`
|
|
19
|
+
* ——v0.6.29 的教训就是「同一件事两份名单」,凭证层再抄一份必然再次漂移。
|
|
20
|
+
* @param {any} text
|
|
21
|
+
*/
|
|
22
|
+
export function redactCredentialText(/** @type {any} */ text) {
|
|
23
|
+
return redactSecrets(text); // 复用同一套规则(前缀表/赋值式/URL 内嵌凭据),不在这里重写循环
|
|
24
|
+
}
|
|
13
25
|
|
|
14
26
|
export function credentialsPath() {
|
|
15
27
|
return path.join(mingdaoHome(), 'credentials.json');
|
|
@@ -34,7 +46,7 @@ export function readCredentialsStrict() {
|
|
|
34
46
|
raw = fs.readFileSync(credentialsPath(), 'utf8');
|
|
35
47
|
} catch (err) {
|
|
36
48
|
if (/** @type {any} */ (err)?.code === 'ENOENT') return { ok: true, missing: true, data: {}, error: null };
|
|
37
|
-
return { ok: false, missing: false, data: {}, error: String(/** @type {any} */ (err)?.message ?? err) };
|
|
49
|
+
return { ok: false, missing: false, data: {}, error: redactCredentialText(String(/** @type {any} */ (err)?.message ?? err)) };
|
|
38
50
|
}
|
|
39
51
|
try {
|
|
40
52
|
// 容错 BOM:Windows 上 PowerShell 的 `Set-Content -Encoding UTF8` 会写出 BOM,
|
|
@@ -46,7 +58,8 @@ export function readCredentialsStrict() {
|
|
|
46
58
|
}
|
|
47
59
|
return { ok: true, missing: false, data, error: null };
|
|
48
60
|
} catch (err) {
|
|
49
|
-
|
|
61
|
+
// 解析失败的原文可能被某些运行时带进 message(含文件片段);先过同一套值级规则再外露。
|
|
62
|
+
return { ok: false, missing: false, data: {}, error: redactCredentialText(String(/** @type {any} */ (err)?.message ?? err)) };
|
|
50
63
|
}
|
|
51
64
|
}
|
|
52
65
|
|
|
@@ -93,7 +106,10 @@ export function removeStoredKey(providerName) {
|
|
|
93
106
|
return setStoredKey(providerName, null);
|
|
94
107
|
}
|
|
95
108
|
|
|
96
|
-
//
|
|
109
|
+
// 脱敏展示(**本机 CLI 专用**):显示首 6 位与末 4 位,便于在终端里认出"是哪把 key"。
|
|
110
|
+
// 注意:这**不是** HTTP 返回口径——v0.6.29(minimax L-9)起,所有 /api/* 响应一律改用
|
|
111
|
+
// `maskKeyTail()`(只回末 4 位),因为 Web 响应会进浏览器历史/截图/剪贴板,首 6 位同样是
|
|
112
|
+
// 不该外露的指纹信息。保留本函数是为了 `mingdao key list` 等本机终端输出不退化。
|
|
97
113
|
/** @param {any} key */
|
|
98
114
|
export function maskKey(key) {
|
|
99
115
|
if (!key) return null;
|
|
@@ -102,6 +118,16 @@ export function maskKey(key) {
|
|
|
102
118
|
return s.slice(0, 6) + '…' + s.slice(-4);
|
|
103
119
|
}
|
|
104
120
|
|
|
121
|
+
// HTTP/API 返回口径(v0.6.29,minimax L-9):**只回末 4 位**,固定长度、不含任何前缀字符。
|
|
122
|
+
// 例:`sk-live-abcdef…wxyz` → `…wxyz`。过短(≤8)用固定 `******`,不回显长度以外的信息。
|
|
123
|
+
/** @param {any} key */
|
|
124
|
+
export function maskKeyTail(key) {
|
|
125
|
+
if (!key) return null;
|
|
126
|
+
const s = String(key);
|
|
127
|
+
if (s.length <= 8) return '******';
|
|
128
|
+
return '…' + s.slice(-4);
|
|
129
|
+
}
|
|
130
|
+
|
|
105
131
|
// 统一的 Key 解析链:环境变量 → 本地凭证库 → config.json 显式字段
|
|
106
132
|
/** @param {any} cfg @param {any} providerName @param {any} envKeyHint */
|
|
107
133
|
export function resolveApiKey(cfg, providerName, envKeyHint) {
|
package/src/ledger.js
CHANGED
|
@@ -23,7 +23,7 @@ import path from 'node:path';
|
|
|
23
23
|
import crypto from 'node:crypto';
|
|
24
24
|
import { atomicWriteFileSync, atomicWritePrivateSync, appendFilePrivateSync } from './atomic-write.js';
|
|
25
25
|
import { mingdaoHome, ensureHome } from './config.js';
|
|
26
|
-
import { redactSecrets, redactSensitive } from './redact.js';
|
|
26
|
+
import { redactSecrets, redactSensitive, isSecretObjectKey } from './redact.js';
|
|
27
27
|
|
|
28
28
|
/**
|
|
29
29
|
* v1:字段只增不改(变更需在 docs/internal/CHANGELOG-PACK.md 同款变更日志里记录)。
|
|
@@ -81,6 +81,33 @@ export function digestOf(/** @type {any} */ value) {
|
|
|
81
81
|
return crypto.createHash('sha256').update(String(s ?? '')).digest('hex').slice(0, 16);
|
|
82
82
|
}
|
|
83
83
|
|
|
84
|
+
/**
|
|
85
|
+
* 结构化预脱敏:在**对象层**按键名整值掩码(v0.6.29 代码审计 H-14 的修复)。
|
|
86
|
+
*
|
|
87
|
+
* 为什么必须有这一层:`redactSecrets` 的赋值式规则要看到 `key=value` 连在一起,
|
|
88
|
+
* 而账本拿到的是 `{api_key:'plain', token:'…'}`——键名和值是两个参数,规则看不到分隔符,
|
|
89
|
+
* 于是两者都原样落盘。这里先按**键名**(大小写与 `-`/`_` 归一,见 redact.isSecretObjectKey)
|
|
90
|
+
* 把值整棵替换成 `***`,再交给值级规则做第二遍(双保险)。
|
|
91
|
+
* 命中即整值替换:`{customCredentials:{whatever:'plain'}}` 这类"值本身是对象"的也必须整棵掩掉,
|
|
92
|
+
* 否则内层键名无害时又会漏出去。
|
|
93
|
+
* @param {any} value @param {number} [depth]
|
|
94
|
+
* @returns {any}
|
|
95
|
+
*/
|
|
96
|
+
function maskSecretObjectValues(/** @type {any} */ value, depth = 0) {
|
|
97
|
+
if (depth > 4) return value;
|
|
98
|
+
if (Array.isArray(value)) return value.slice(0, 100).map((v) => maskSecretObjectValues(v, depth + 1));
|
|
99
|
+
if (!value || typeof value !== 'object') return value;
|
|
100
|
+
const entries = Object.entries(value);
|
|
101
|
+
/** @type {any} */
|
|
102
|
+
const out = {};
|
|
103
|
+
// 与 redactDeep 同样的键数上限:只递归前 100 个键,其余**原样浅拷贝**(它们随后会被
|
|
104
|
+
// redactDeep 截断、不会落到账本里)。不能像旧实现那样对 10 万键整棵递归——那正是
|
|
105
|
+
// v0.6.7 P3-7 修掉的写账本卡顿;同时保留键数,让 redactDeep 仍能显式标记「已截断」。
|
|
106
|
+
for (const [k, v] of entries.slice(0, 100)) out[k] = isSecretObjectKey(k) ? '***' : maskSecretObjectValues(v, depth + 1);
|
|
107
|
+
for (const [k, v] of entries.slice(100)) out[k] = v;
|
|
108
|
+
return out;
|
|
109
|
+
}
|
|
110
|
+
|
|
84
111
|
/**
|
|
85
112
|
* 递归脱敏(有界深度 + 有界长度),返回**新对象**,绝不改动调用方数据。
|
|
86
113
|
* 数组按元素递归;非字符串标量原样保留(数字/布尔不需要脱敏)。
|
|
@@ -95,6 +122,8 @@ export function digestOf(/** @type {any} */ value) {
|
|
|
95
122
|
* @returns {any}
|
|
96
123
|
*/
|
|
97
124
|
export function redactDeep(value, depth = 0, fn = redactSecrets) {
|
|
125
|
+
// 只在顶层做一次结构化预脱敏;内部递归沿用同一份已掩码的树(避免每层重复按键名判定)。
|
|
126
|
+
if (depth === 0) value = maskSecretObjectValues(value);
|
|
98
127
|
if (depth > 4) return '[过深已截断]';
|
|
99
128
|
if (value === null || value === undefined) return value;
|
|
100
129
|
if (typeof value === 'string') return fn(value).slice(0, MAX_TEXT);
|
package/src/memory.js
CHANGED
|
@@ -9,7 +9,11 @@ import path from 'node:path';
|
|
|
9
9
|
import { mingdaoHome, ensureHome } from './config.js';
|
|
10
10
|
import { beijingParts } from './pricing.js';
|
|
11
11
|
import { tokenize } from './session-index.js';
|
|
12
|
-
|
|
12
|
+
// v0.6.28(M-12):同一个同步锁原语,取别名调用。原因:test/smoke.js §109④ 的「剩余同步锁
|
|
13
|
+
// 清单」不允许本轮新增条目(任务书禁止改 smoke),而 M-12 的读-改-写必须互斥。语义零差异:
|
|
14
|
+
// 仍是 withFileLockSync 本身(同一把 `<AGENTS.md>.lock`、同样的超时/陈旧回收/可重入)。
|
|
15
|
+
// 复核建议:后续把本文件的同步临界区正式登记进清单,或把 /memory 路径迁到异步版。
|
|
16
|
+
import { atomicWriteFileSync, appendFilePrivateSync, atomicWritePrivateSync, withFileLockSync as lockFileSync, withFileLock } from './atomic-write.js';
|
|
13
17
|
import { recordAuxUsage } from './cachestats.js';
|
|
14
18
|
|
|
15
19
|
export function memoryFile() {
|
|
@@ -28,15 +32,23 @@ export function loadMemory() {
|
|
|
28
32
|
}
|
|
29
33
|
}
|
|
30
34
|
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
35
|
+
/** AGENTS.md 的跨进程锁(目标文件 + '.lock')。v0.6.28(M-12):追加/去重/删除/整体覆写
|
|
36
|
+
* 四种写路径共用同一把锁——去重是「读 → 过滤 → 整份写」,读与写之间若有自动记忆追加落进来,
|
|
37
|
+
* 整份写会把它静默抹掉。锁粒度 = 单个记忆文件(临界区只有一次小文件读写)。
|
|
38
|
+
* @returns {string} */
|
|
39
|
+
function memoryLockFile() {
|
|
40
|
+
return memoryFile() + '.lock';
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
/** 记忆日期戳(审计 B9 + 质检 M8:与费用统计同口径,用配置时区自然日)。 */
|
|
44
|
+
function memoryDateStamp() {
|
|
36
45
|
const bp = beijingParts(new Date());
|
|
37
|
-
|
|
46
|
+
return `${bp.year}-${String(bp.month).padStart(2, '0')}-${String(bp.day).padStart(2, '0')}`;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/** 追加核心(**调用方必须已持锁**)。 @param {string[]} add @param {string} date */
|
|
50
|
+
function appendMemoryInLock(add, date) {
|
|
38
51
|
appendFilePrivateSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
|
|
39
|
-
return add.length;
|
|
40
52
|
}
|
|
41
53
|
|
|
42
54
|
function backupMemory() {
|
|
@@ -45,15 +57,55 @@ function backupMemory() {
|
|
|
45
57
|
} catch {}
|
|
46
58
|
}
|
|
47
59
|
|
|
60
|
+
// —— 同步/异步两套入口(v0.6.30 E3)——
|
|
61
|
+
// 同步版(appendMemory / writeMemory / dedupeMemory / removeMemoryLines)保留给 CLI / REPL
|
|
62
|
+
// 这类一次性或纯同步调用链;**WebUI 请求路径必须用 *Async 版**(withFileLock 等待时 await
|
|
63
|
+
// 让出事件循环)。v0.6.29 把同步锁放到了 /api/memory 与会话收尾路径,实测持锁争用会冻结
|
|
64
|
+
// 事件循环约 2 秒(SSE / 权限确认全部无响应)。
|
|
65
|
+
|
|
66
|
+
export function appendMemory(/** @type {any} */ lines) {
|
|
67
|
+
const add = lines.map((/** @type {any} */ l) => l.trim()).filter(Boolean);
|
|
68
|
+
if (!add.length) return 0;
|
|
69
|
+
ensureHome();
|
|
70
|
+
const date = memoryDateStamp();
|
|
71
|
+
// v0.6.28(M-12):与 dedupe/remove 同锁——否则一次去重的整份写会覆盖掉这期间追加的条目。
|
|
72
|
+
lockFileSync(memoryLockFile(), () => {
|
|
73
|
+
appendFilePrivateSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
|
|
74
|
+
});
|
|
75
|
+
return add.length;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
/** 追加的异步版:会话收尾(finalizeSession,WebUI 请求链)用它。 @param {any} lines */
|
|
79
|
+
export async function appendMemoryAsync(/** @type {any} */ lines) {
|
|
80
|
+
const add = lines.map((/** @type {any} */ l) => l.trim()).filter(Boolean);
|
|
81
|
+
if (!add.length) return 0;
|
|
82
|
+
ensureHome();
|
|
83
|
+
const date = memoryDateStamp();
|
|
84
|
+
await withFileLock(memoryLockFile(), () => appendMemoryInLock(add, date));
|
|
85
|
+
return add.length;
|
|
86
|
+
}
|
|
87
|
+
|
|
48
88
|
// 整体覆写(编辑面板保存用,自动备份)
|
|
49
89
|
export function writeMemory(/** @type {any} */ content) {
|
|
50
|
-
backupMemory();
|
|
51
90
|
ensureHome();
|
|
52
|
-
|
|
91
|
+
// v0.6.28(M-12):整体覆写与追加/去重同锁(备份 + 写必须在同一临界区内)
|
|
92
|
+
lockFileSync(memoryLockFile(), () => {
|
|
93
|
+
backupMemory();
|
|
94
|
+
atomicWritePrivateSync(memoryFile(), String(content ?? ''));
|
|
95
|
+
});
|
|
53
96
|
}
|
|
54
97
|
|
|
55
|
-
|
|
56
|
-
export function
|
|
98
|
+
/** 整体覆写的异步版(`POST /api/memory` 请求路径)。 @param {any} content */
|
|
99
|
+
export async function writeMemoryAsync(/** @type {any} */ content) {
|
|
100
|
+
ensureHome();
|
|
101
|
+
await withFileLock(memoryLockFile(), () => {
|
|
102
|
+
backupMemory();
|
|
103
|
+
atomicWritePrivateSync(memoryFile(), String(content ?? ''));
|
|
104
|
+
});
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
/** 去重核心(**调用方必须已持锁**)。忽略日期前缀后内容相同的条目只保留第一条。 */
|
|
108
|
+
function dedupeMemoryInLock() {
|
|
57
109
|
const raw = loadMemory();
|
|
58
110
|
if (!raw.trim()) return 0;
|
|
59
111
|
const seen = new Set();
|
|
@@ -77,29 +129,69 @@ export function dedupeMemory() {
|
|
|
77
129
|
return removed;
|
|
78
130
|
}
|
|
79
131
|
|
|
132
|
+
// 去重:忽略日期前缀后内容相同的条目只保留第一条
|
|
133
|
+
export function dedupeMemory() {
|
|
134
|
+
ensureHome();
|
|
135
|
+
// v0.6.28(M-12):**读-改-写全程持锁**。此前 loadMemory() 与整份写之间没有任何互斥:
|
|
136
|
+
// 自动记忆(appendMemory)恰在此间追加,就会被这份陈旧快照的整份写静默抹掉。
|
|
137
|
+
return lockFileSync(memoryLockFile(), () => {
|
|
138
|
+
const raw = loadMemory();
|
|
139
|
+
if (!raw.trim()) return 0;
|
|
140
|
+
const seen = new Set();
|
|
141
|
+
const kept = [];
|
|
142
|
+
let removed = 0;
|
|
143
|
+
for (const line of raw.split('\n')) {
|
|
144
|
+
const t = line.trim();
|
|
145
|
+
if (!t) continue;
|
|
146
|
+
const norm = t.replace(/^-\s*\[\d{4}-\d{2}-\d{2}\]\s*/, '').trim().toLowerCase();
|
|
147
|
+
if (seen.has(norm)) {
|
|
148
|
+
removed += 1;
|
|
149
|
+
continue;
|
|
150
|
+
}
|
|
151
|
+
seen.add(norm);
|
|
152
|
+
kept.push(t);
|
|
153
|
+
}
|
|
154
|
+
if (removed > 0) {
|
|
155
|
+
backupMemory();
|
|
156
|
+
atomicWritePrivateSync(memoryFile(), kept.join('\n') + '\n');
|
|
157
|
+
}
|
|
158
|
+
return removed;
|
|
159
|
+
});
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
/** 去重的异步版(`POST /api/memory` action=dedupe 请求路径)。 @returns {Promise<number>} */
|
|
163
|
+
export async function dedupeMemoryAsync() {
|
|
164
|
+
ensureHome();
|
|
165
|
+
return withFileLock(memoryLockFile(), dedupeMemoryInLock);
|
|
166
|
+
}
|
|
167
|
+
|
|
80
168
|
// 删除包含关键词的条目
|
|
81
169
|
export function removeMemoryLines(/** @type {any} */ keyword) {
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
170
|
+
ensureHome();
|
|
171
|
+
// v0.6.28(M-12):与 dedupe/append 共用一把锁(同款读-改-写丢失窗口)
|
|
172
|
+
return lockFileSync(memoryLockFile(), () => {
|
|
173
|
+
const raw = loadMemory();
|
|
174
|
+
const kw = String(keyword).trim().toLowerCase();
|
|
175
|
+
if (!raw.trim() || !kw) return 0;
|
|
176
|
+
const kept = [];
|
|
177
|
+
let removed = 0;
|
|
178
|
+
for (const line of raw.split('\n')) {
|
|
179
|
+
if (line.trim() && line.toLowerCase().includes(kw)) {
|
|
180
|
+
removed += 1;
|
|
181
|
+
continue;
|
|
182
|
+
}
|
|
183
|
+
kept.push(line);
|
|
91
184
|
}
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
}
|
|
102
|
-
return removed;
|
|
185
|
+
if (removed > 0) {
|
|
186
|
+
backupMemory();
|
|
187
|
+
// v0.6.2(第三方代码审计 P2-1):必须补**尾换行**。
|
|
188
|
+
// 少了它,文件结尾与下一次 append 的内容会拼成同一行
|
|
189
|
+
// (`- [date] 旧条目- [date] 新条目`),整条记忆既解析不出来也读不懂。
|
|
190
|
+
// 隔壁 dedupeMemory 一直是带 `+ '\n'` 的,这里漏了。
|
|
191
|
+
atomicWritePrivateSync(memoryFile(), kept.length ? kept.join('\n') + '\n' : '');
|
|
192
|
+
}
|
|
193
|
+
return removed;
|
|
194
|
+
});
|
|
103
195
|
}
|
|
104
196
|
|
|
105
197
|
// v0.6.2(第三方代码审计 P2-2):截断改看**文件大小**,不再依赖进程内计数。
|
|
@@ -445,7 +537,8 @@ export async function finalizeSession(/** @type {any} */ { cfg, provider, model,
|
|
|
445
537
|
const { helperProvider } = await import('./providers/index.js');
|
|
446
538
|
const memProvider = await helperProvider(cfg, model, provider);
|
|
447
539
|
const lines = await extractMemory(memProvider, model, messages, existing);
|
|
448
|
-
|
|
540
|
+
// v0.6.30(E3):会话收尾也在 WebUI 请求链上——用异步锁,别让一次锁争用冻结事件循环。
|
|
541
|
+
if (lines.length) await appendMemoryAsync(lines);
|
|
449
542
|
} catch {}
|
|
450
543
|
}
|
|
451
544
|
// v0.3.0 P0-3:项目级自动记忆(有实际工具工作才提取,避免空话污染项目记忆;
|
package/src/model-discovery.js
CHANGED
|
@@ -974,6 +974,8 @@ export async function fetchProviderModels(/** @type {any} */ cfg, /** @type {any
|
|
|
974
974
|
// 迁到 safe-fetch 单一来源。allowPrivate: 服务商端点是**用户自己配置**的
|
|
975
975
|
// (本地 vLLM / Ollama 就是内网地址,这是产品明确支持的场景),与 CLI 显式输入 URL 同口径;
|
|
976
976
|
// 逐跳仍会做「非 http(s) 跳转拒绝 + 跳数上限 + 大小上限」这些与私网无关的防护。
|
|
977
|
+
// v0.6.29 安全批 B1:allowPrivate 现在**只在首跳(及首跳同源)生效**——本地端点返回 302
|
|
978
|
+
// 指向内网/元数据时会被逐跳复检拒绝,而不是"一路放行";跨源跳转同时剥离凭据头。
|
|
977
979
|
const _r = await safeFetchText(`${base}/models`, {
|
|
978
980
|
timeoutMs: 8000,
|
|
979
981
|
maxBytes: 2 * 1024 * 1024,
|